{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic Regression with a Neural Network mindset\n",
    "\n",
    "Welcome to your first (required) programming assignment! You will build a logistic regression classifier to recognize  cats. This assignment will step you through how to do this with a Neural Network mindset, and will also hone your intuitions about deep learning.\n",
    "\n",
    "**Instructions:**\n",
    "- Do not use loops (for/while) in your code, unless the instructions explicitly ask you to do so.\n",
    "- Use `np.dot(X,Y)` to calculate dot products.\n",
    "\n",
    "**You will learn to:**\n",
    "- Build the general architecture of a learning algorithm, including:\n",
    "    - Initializing parameters\n",
    "    - Calculating the cost function and its gradient\n",
    "    - Using an optimization algorithm (gradient descent) \n",
    "- Gather all three functions above into a main model function, in the right order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "- [1 - Packages](#1)\n",
    "- [2 - Overview of the Problem set](#2)\n",
    "    - [Exercise 1](#ex-1)\n",
    "    - [Exercise 2](#ex-2)\n",
    "- [3 - General Architecture of the learning algorithm](#3)\n",
    "- [4 - Building the parts of our algorithm](#4)\n",
    "    - [4.1 - Helper functions](#4-1)\n",
    "        - [Exercise 3 - sigmoid](#ex-3)\n",
    "    - [4.2 - Initializing parameters](#4-2)\n",
    "        - [Exercise 4 - initialize_with_zeros](#ex-4)\n",
    "    - [4.3 - Forward and Backward propagation](#4-3)\n",
    "        - [Exercise 5 - propagate](#ex-5)\n",
    "    - [4.4 - Optimization](#4-4)\n",
    "        - [Exercise 6 - optimize](#ex-6)\n",
    "        - [Exercise 7 - predict](#ex-7)\n",
    "- [5 - Merge all functions into a model](#5)\n",
    "    - [Exercise 8 - model](#ex-8)\n",
    "- [6 - Further analysis (optional/ungraded exercise)](#6)\n",
    "- [7 - Test with your own image (optional/ungraded exercise)](#7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='1'></a>\n",
    "## 1 - Packages ##\n",
    "\n",
    "First, let's run the cell below to import all the packages that you will need during this assignment. \n",
    "- [numpy](https://numpy.org/doc/1.20/) is the fundamental package for scientific computing with Python.\n",
    "- [h5py](http://www.h5py.org) is a common package to interact with a dataset that is stored on an H5 file.\n",
    "- [matplotlib](http://matplotlib.org) is a famous library to plot graphs in Python.\n",
    "- [PIL](https://pillow.readthedocs.io/en/stable/) and [scipy](https://www.scipy.org/) are used here to test your model with your own picture at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import copy\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import scipy\n",
    "from PIL import Image\n",
    "from scipy import ndimage\n",
    "from lr_utils import load_dataset\n",
    "from public_tests import *\n",
    "\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='2'></a>\n",
    "## 2 - Overview of the Problem set ##\n",
    "\n",
    "**Problem Statement**: You are given a dataset (\"data.h5\") containing:\n",
    "    - a training set of m_train images labeled as cat (y=1) or non-cat (y=0)\n",
    "    - a test set of m_test images labeled as cat or non-cat\n",
    "    - each image is of shape (num_px, num_px, 3) where 3 is for the 3 channels (RGB). Thus, each image is square (height = num_px) and (width = num_px).\n",
    "\n",
    "You will build a simple image-recognition algorithm that can correctly classify pictures as cat or non-cat.\n",
    "\n",
    "Let's get more familiar with the dataset. Load the data by running the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the data (cat/non-cat)\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We added \"_orig\" at the end of image datasets (train and test) because we are going to preprocess them. After preprocessing, we will end up with train_set_x and test_set_x (the labels train_set_y and test_set_y don't need any preprocessing).\n",
    "\n",
    "Each line of your train_set_x_orig and test_set_x_orig is an array representing an image. You can visualize an example by running the following code. Feel free also to change the `index` value and re-run to see other images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 64, 3)\n",
      "y = [1], it's a 'cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaAAAAGfCAYAAAAZGgYhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABe9ElEQVR4nO29e5Bd1X3lv877Pvp23+6W1JKQhGUbW2AMxoCxgjNJsBKGSlx4oDJOitQwGVdcZgQx4KnEmopNQiUWY9fExIksxx4GnN+E0ZhU4YRMGcYl23LZI7CRTRmbjMxDIIHULQmp3/d1Hr8/FHfcvdfXVoPwaZr1qeoq+PbWuXufs8/Zfe9edy2vKIoCQgghxM8Zv+wOCCGEeG2iBUgIIUQpaAESQghRClqAhBBClIIWICGEEKWgBUgIIUQpaAESQghRClqAhBBClIIWICGEEKWgBUgIIUQphK/UgXfs2IFPfvKTGB0dxYUXXoi//Mu/xDve8Y6f+e/yPMfhw4fRaDTged4r1T0hhBCvEEVRYGpqCmvXroXv/5T3OcUrwK5du4o4jov//t//e/HDH/6w+L3f+72i2WwWY2NjP/PfHjp0qACgH/3oRz/6eZX/HDp06Kc+772iOPNmpJdddhkuvfRS/NVf/RWAU+9q1q9fj5tuugkf+chHfuq/nZiYQLPZxL/+pXchCue/QUvq/fTf1PpXOLU4qdO29cEhWg+8nNbzXs+pNQaatG2RtfgxMvcYABCHEa23pyecmvVm0PrrIgx5vT077dQqfYP84GmHlnudGVo/9MzTtF4j1214ZBVtG/n8OnSmX6T1rMX7EtX6nFoQ8/P93NMHaL3d4tfzrPWvc2orznojbVsb4HPWBx9nXOHt0yx1ap1ORtsWfkzrnp/QelRvum3jKm3rG/PKi/n9FjT43Oq03bnVnZnkbY8+Q+sAH39QuPdbEAa0bZFbjz+jXvDrliQVpxZGxgdMAZ+Hs9PuvQkAszPu8wAA/Kjmdo+/IqzHfG6MP+u61yft8P4dP/y8U+v2evj/vvh3GB8fx8DAgNGrV+AjuG63i3379mHbtm1zNd/3sWXLFuzdu9dp3+l00On8y2CnpqYAAFEYOgtQFPELF8fuDRfH/GZjEwX4KQsQecBXKvwYRWZc5IxPfmsBQq/tlM7UAlSQxdAaD/i6iQDuwxAAYvP6uPVKYjwMff5Q8br82Gl2+q8ZJPzBHBsPirzHr1vCxlPh46ka59ZcgKr8wc8WIN/j16EwFhovMM551X2QeYlbA17CAlR3/xAAAN8n16cwrn2FnxN7AXKvZxgtcgGy/i63FiByne0FiM/DIuPjyTP+h6Afuedl8QsQH0/muw+cnvFAYM/fH/OztlHOuAjh+PHjyLIMIyMj8+ojIyMYHR112m/fvh0DAwNzP+vXrz/TXRJCCLEEKV0Ft23bNkxMTMz9HDp0qOwuCSGE+Dlwxj+CW7FiBYIgwNjY2Lz62NgYVq9e7bRPkgQJ+Timb/gsxNH8t3bVRpO+ZlxvuLWIf9xgffQRGfsDCNy37r2u+xEZAPg+f5vb6/D2MN5yeyG5LNbb85zX/ZB/hOIF7tv5zDi29deJ9ba63s/3L8LQfYtebQzTtlFonMNZvj9QeHwPqCC9T6ruPAH4HhUAZD1+XmKyvxQZH+955KMMAChyXu91Z2k9it3rGTb5eHLwuZzB+OiHffyc8v2vwjOOYewXeh1rPORjtYJ/XJcZ59Yv+EeQKMjHbcZHZ3luHcN4ThgfM4NeTuPaGx81dttTvD1/RYCN32gc+PxRH7BnDQCPXP80Nz6CIx8/Fj9N+fYTnPF3QHEc4+KLL8bu3bvnanmeY/fu3di8efOZfjkhhBCvUl6R7wHdeuutuP7663HJJZfgHe94B+68807MzMzgd3/3d1+JlxNCCPEq5BVZgN73vvfh2LFj+NjHPobR0VG87W1vw4MPPugIE4QQQrx2ecWcEG688UbceOONr9ThhRBCvMopXQUnhBDitckr9g7o5VJ0p1AU8xUnnQmutIkjdx0N+rhCyLfUccY3pQPyZTfPULEUhqLGMxQo8Pj6zxRCaYerkiwFW259qY98Czvrdmnb1FAZWeNvG9/YrvStdGpx3fh2dM4Vg4Hxzfze+HFaJ9/RQ9LHX3PFmg20nqb8vMREtWl+0z4zvuhnfLkwsr4QnbtzyAf/kqtnfEEz73A3iZzMIS/iXyxFZnxRtsUVXH7rJK1HZE6YCi7P0oEZKjPPPVfWN/79kB8j6xlz3/xiJakbSrCUuAwAQM+oZ+aXZd25whSnp5ryeWV94dZjXzY3jhEF7thzUmPoHZAQQohS0AIkhBCiFLQACSGEKAUtQEIIIUphyYoQfPSc1dEjjsAA0Bofc2pezjeQgwq3qEmNTe6E2K6EEd/8TWqGq7Rhl2PZl/iRu5GYGBYgM2TsANCZ5ZvCII7IPaMfVoyET+zuASA0zmF1wI3AyAyBg7EnjKhqOJAbG9HM5ZfZ2QBAY5jfBidf5OfWJ5viecrPSWFYuhRWe2MTOSe3amHEYmTGfWImr4Su4KCX8jk7e4JHV6Rd3pekyu11oqp7boMqj27ozozTumWrVXiuIMQLDMdz45z4xnXIjI14n8zD9iwX5VjWXKlxzgtjnDmZW9b8yYxjW88mZjdmaKa4bZEx7xeid0BCCCFKQQuQEEKIUtACJIQQohS0AAkhhCgFLUBCCCFKYcmq4IIgRLBQuWIoKyok0z6KueVOtcEteiyBUE7UPb0OV5h5GVdZWcq7osvXf5+E4FnBZpV6k9ZnJ0/QehS5x2ZWLIAddpca6qtqjY+zf9gNn5s8fpi2bfRzu5y4aljDGKo5jyjVPMMaJa7xQLqE2cUAgO+ew8yw7QmMW6wwzq3nG1YqRNmWG2pE+FwxmefcLqg1ccytTfM53mtxZZdHzgkAZD2u+ApbbsBgVOGhg5a60jrnYPdKxvuXF8YxCj6xAqJQBYCQKAnbM3w8acpVirkR+GZZ+gTEVsy07TFUgJaKlM1Dy7bIIx5KrMbQOyAhhBCloAVICCFEKWgBEkIIUQpagIQQQpSCFiAhhBClsGRVcL1ez9FnGEIwdIkqK6otTjUVRYZXFFEOWZ50GfFPAoCsPU3rSZWrr3yi+vEMBWB1cBWtp0bIXBC7nmqp0e/e9Cyt50ZwVq3J+xKQcKqxw9xTLArPofX+fu4pZimEmE+WZyiYvIwrdvoGXfUeAES+e/1N1Y9lv5ZwxSBTQJ56AfdAfsDPSWaorDozPJCu13avc24ozNIeD0a08s7Q4nMIJHjPCoWMKly5Gln3Dz2Hxt/axvPA8vDzjaC1Dgnky3pWwJzh+WY8V/KCP5syMm8zQ0mX1I35FvMJWiOBnl0jcLLTcp+/RcDH7rz+abUSQgghzjBagIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpLVgUXBqd+5mP4MxElFFP2AMD0Ca76qA8YfmBEaeOH3GvLUjBlXa4cKjKuFCm6bh/jxgraNoi4T1Z9hZGiSBRsWY+fq6nj3POtO8PbN0YMpQ1JdEwN1ZTlZeUH/G+l0FAv+sT7yvf4/Jk89hyt1+rGOSfSNr/gSkLLw88nPl6AKcqCH7mqTmsedmZHab0wUmg9cl6Yl96pOr8O1hzqGWrMtMfUWnxSRBXuS1fp5/dPSJSekeHHaN2zRW4o0nr8CvVIenDW42MvjHNYWO8HLJ9KUrfG2RjkabNJhT8/QMbTDnn/UuIlGbT5/bAQvQMSQghRClqAhBBClIIWICGEEKWgBUgIIUQpLFkRQuBHCBYEa4UR33StEtsIK2QsN5LncsOOhW4kGhuXlh1LpWqE4KVcnABiyVF0eNugxgPcKv18A709Ne4eo3WSts2NDeRel2/QwuPnxQ9dC5xqP98U7Rjj9MDHacVeeaG7yZ8am8KjzzxJ62vfZGzorlrv1NonDxn945vWoWELFMTcXiequpvFaYtbPAWGOCGK3M15gIcxWmGExow17X96XW4N0yNimMLw88lzM3WQlkOysZ4aQiArSC8IjUej8fygAhfjfsioAAPoGeMPYm4rVhtoOrVGk9tHMWsdwBYtZETEZZxupCS8L2hZM2U+egckhBCiFLQACSGEKAUtQEIIIUpBC5AQQohS0AIkhBCiFJasCs4PAtcmwzOCmXquAsdSu0Uxt0CJEq4QihISDmdZaViBUkbdM9Z/jyinUhJ4BQCVfq56SQwVYEbUR9MdbpvB7VKAXmrYtBiKIs93VVnVPq5qS9vc/icj1iAAkPe4WmuhghKwxzM9xW1kZsfHaH1k3Rvctrwb5lyJEsP6qcHVgUWXKN4MVZJlLxMRixoAyMmBMkORZVkFWaq5LOPH6Xbce8InIXUAkBf8+mTEAgYAgpY7x4PIOCdGMGBY4efKAz9OQgIwe13e727bUIhFvC+Jca9UiQouSrgCMoi56tI3rKJyYm9WpPz+qVTdc1WY+tQFr39arYQQQogzjBYgIYQQpaAFSAghRCloARJCCFEKWoCEEEKUwpJVwcWVKuIFyg2mDjv1C6Ia6/CwKkuRZnk8hcTHzDeUJp4VbtXjffENrygUrmdZlvJjdGcmaL3eP0TrUdVV67CQOgDoGGqdruHXZv01w4LTQiOQbfroQVrPUq4O66Xc361FvKiqLa5KsoLADFEWQNR+3S5XZFXdVEUAQGj4A1oqzTR3x+n3jOtAwvgAHmAGAH7mtjeD8Yi6EACKnI+zPcv72CHKSxaMBwCB4QHZ6XBlaBC656pSMxSAxjW2VLSBcW7DzD3+7MRx2tYL+HjiGp/jtUaTtycKXZ+o1wDAy7mCrcitgEH3mWApOkMSVBca834hegckhBCiFLQACSGEKAUtQEIIIUpBC5AQQohS0AIkhBCiFBatgvvGN76BT37yk9i3bx+OHDmC+++/H+9973vnfl8UBW677TZ8/vOfx/j4OC6//HLs3LkT55xzzqJep9vpAMV8iUoUu6oPAIiIh1JgtTU8ngJDweYTr6jI8FkLDNmUpYIrUsv7injbGR5p3Wmugks6XB3ms2MbaZEsFREAPEM61O1yT7kwcZV3baPf1t9EuSHh6vSMhEpybtuz/BwGHj9GzVAShsRTrWf46cUVrmyKa03eF6IoAoBeShRVZjqnMZeNOQ7PVUhZSi2mogQAP+aKNM8YD7qu4q0wxtNp83PbM7z9ooQcx1CvBURdCACp4WFX7TM8Fkn7lHhUAkC9f4Qf2/ABrBrnPI7cMYWGitLKDk4NpStTxlrKNp+oQpk/J/23p9XqJ5iZmcGFF16IHTt20N9/4hOfwKc//Wl89rOfxSOPPIJ6vY4rr7wSbWMSCSGEeG2y6HdAV111Fa666ir6u6IocOedd+KP/uiPcPXVVwMA/uZv/gYjIyP40pe+hN/6rd9y/k2n00HnJ76zMzk5udguCSGEeBVyRveADhw4gNHRUWzZsmWuNjAwgMsuuwx79+6l/2b79u0YGBiY+1m/fv2Z7JIQQoglyhldgEZHRwEAIyPzP+McGRmZ+91Ctm3bhomJibmfQ4cOnckuCSGEWKKUbsWTJAmSxNo4E0IIsVw5owvQ6tWrAQBjY2NYs2bNXH1sbAxve9vbFnUs3wscNU9qJCAyvU4lNpIoQ2PIRppnSrzGvBZXUyHmyiHmJweYwhzkRJVUWEo1w8etO0sSNAF4hdu+O8v33SwVT1zlyY1xtY/WA6IaCwyzsUaTK4GsqepZKbnkvLQmTvAjG+KwqMb92pjnH/POAoBe1/DgshIjDb+toOKqrzJj7L7PXxM9LgQKQvcPwCDi1z5prKD1PvA/Imf5aUG3d8yppYaSsNXmB0lTQ2kVuOc2MjzPkBrPFKLcBID64Fm03pl1VZ2+cd9b98/A8EparxjK3ZA8ywLDCy415mFqiMNyonT1C36uvMB9Tc9QljrHPK1Wp8nGjRuxevVq7N69e642OTmJRx55BJs3bz6TLyWEEOJVzqLfAU1PT+Opp56a+/8DBw7gsccew9DQEDZs2ICbb74Zf/qnf4pzzjkHGzduxEc/+lGsXbt23neFhBBCiEUvQI8++ih+5Vd+Ze7/b731VgDA9ddfj3vuuQd/8Ad/gJmZGXzgAx/A+Pg43vWud+HBBx8030YKIYR4bbLoBeiXf/mXzW8sA6cyPW6//XbcfvvtL6tjQgghljelq+As6gMDSBYE0lkbuiHZBAsMK5E8MzaFrXAvstHnVQ2bkvoArScVvkHrGeF4KdmZyw3bkcII1MqM0Djk7qZjz7DQKXLev9BQLeaGfUnacUUbsfGO2DOuj2l1Y4hKPLIZ6we83/3G5m+1zkUIAQnTy40N/qzFBR6ZEZhoGZikRITiGX8IsrEDpnMPspxsLhsbzr7Rw5jvt6Ni3CuzM65VVmEIGdKWYStlqEeY0Cgw5kls2GoNb3gjrVcHhmm9NXXSqYUVLmTwDMFTZImYEn5yC3LdCs941lhhmYYYhs1nK+yOHuL0NAgyIxVCCFEOWoCEEEKUghYgIYQQpaAFSAghRCloARJCCFEKS1YFV/Q6KBbYOUQhV4kwZU7HCDzLjGAzi/aMG8o2c4KEgwGo9DVpvW+YB1BVKjw0L4xdS5tkiLfNicIMAHyi1AKArOuOPwdXyGSGSs9SuFh2NEwF5xsqxUqVjzMg9iqAHTCIwD1OY8Vq3jbnwXNRjVsLsb/a4gpXzKWGwrA746qmAMADPw7INQoN66Oix1VjhWHPBDBfJCu8jpcLoq481Zxft4yorNi9BgCVhhEM6PHOxInb9/5V62jb5iruvt9cw+ut49wsuddx1Y5exOdyUjUCLX1+T1g2YTmxJvONsEhrHmaGFVGPhFHmxvlm/cuIhRn9p6fVSgghhDjDaAESQghRClqAhBBClIIWICGEEKWgBUgIIUQpLFkVHPzw1M9PYgRw9bqu4qI1wxU/vbbhkWYou0LiN5UY6iMrxKrdMkKfDHOumKjjooSrvSIj3Mr0CYtcpU3/Sq4OG33uAK37xHsP4MomAOjMED80j6t1an1cIeQbCsggPkzreeoev6/Jw9QsiysrNI8pfKzwsd4sV7vlRpiaafRLFEi5MWmt4MZuh9c7JJTM8hJMjf71yPkGgLTL672e25eUedIBiMDr1vVctW6jU2uuPZu2rRvebl02ZwG0J7kCNidefWHM783AmMuZoWDLDA9MpG69Z3hGdltcYVgY/o3MdzO1/AFJ4GRq9MP5t6fVSgghhDjDaAESQghRClqAhBBClIIWICGEEKWgBUgIIUQpLFkVXO55jveQ53EFTlG4CiFLaYKY+yolda6+qvW7irfQSC60/Mp6ba7IO36UK7iyntu+kvDXjBPuNzW0mqt+akRh1z/yOtp2ZCNX/Fg+bpnle9YiiagRV40FRFEDAFmPq3gSQx3o1VwvPOtchZHltcX9rNK2O5485aqxTmuc1ntd7uGX+FyVlZM5nve4kq49y/syOzPF20++6NQyorACgMLwJZuZ5seemjLUZCThNgyNxNqBQVofGubnavgsd+43Vp1F21rOkCde4ApQy++w3XbnSl+foRY1FJCpkfrrGbHH7H4LrYRgj/clsFJYY/de6ba4v2abXPt2y1AbL0DvgIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpLVoTg+x58f/7Ga2FYdXRn3Q3qNglUAoC+5ipabxgbmtU+NyAsivlmqW8ENk1P876MvcBFCBXi9NPyuc3P0UN8s/TI1x+m9U1vfoNTe8NZ/JyMvPFCWu8ZYoPZk0doffq4W683V9K2lhONaZUU8ylcabg2LZadT6/Dr09mCAUKYnUTRLwfgxveTOtBHw9ZmzIspCZPHjutfgBA4PF6YVja9IjtzuQxHryWGUF13YKLSiYn+cZ1Tixg+upcJFI1Aun6DaENCx6s1PixLcGGJTaIjODBLD9K2vLnRFjhFj0wn298TmQkeNBL+HWIjPBLS/hA73GPX/uCiCQKU94xH70DEkIIUQpagIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpLVgWXd3vIMV9VZgW4TU+OO7UusUsBgDDgQ6718ZC5NGGWLtz+pdbgCpnYCI1rHuXqs4mWqxqLDLuYtmGLc3ySK2eePHjQqY09/yRte/4559D68Areb8tGZ2LMVfulPW4v0t/kasTEUBRFTDIIwCdBgp3pE7TtLLGiAYCYXHsAqPa74+9b/xba9vA4V4F942t7aT3MuXVNPukG2206ZxNtW4+4gstbGPD4z8Q1d34m/VyleOz5Z2l9usVti/KcK0Obw+QcDvNgxMGzXsePsYbXq3V3TgQRv5YzJ5+n9chQNbZnuY1OGLsq1aTapG2LjB/DC/g9DvBzWOTucQrjke4ZCjbfek3S3rLDYsmNecrnoPP6p9VKCCGEOMNoARJCCFEKWoCEEEKUghYgIYQQpaAFSAghRCksWRVcZ3YaRTpf4dXp8pAsFnhmmYdlXa7OaJ0co3UfrlrLS7l/UmAs5wMreRjW2RtdXzYAeOIpdzyez5UwAVHCAEDs83H2Zlwl2DHDC+27k1yR9QvvfCeth4bSKCBBcK1ZHmA2Mz3Ojx3yULLACEhj1yLtct+vwFACNVZuoPWptnv9nzbCBUen+Lndv/+HvC9drppb1ecGJsaW75cR9tdt83OeZmyucJViVOWehFFhBJ4Z/ogNooIbWsvP9+BKro6r93F1aUJ831hoJQCEFa7cTIgHJGD7BjaGyaPUUB1anpax5TNnhQNm7vErxvUJjKC6rODH9gr3udJp8fnD7sFOWyo4IYQQSxgtQEIIIUpBC5AQQohS0AIkhBCiFLQACSGEKIUlq4LzgxD+Ap+zIucqph5TthneR5avUpsq6YA8IyqRfkORZSiH6n1NWl+9hqt7xon67NDkC7RtxIeD4QHukTY7445z1lBqdTLuJ2e1H16zhtbDyFUapR2ukukYiaDob9KypQQLiAyuN8vVi5UGv56Zx2+Pr+15yKnV1/OxT4xxdWX7RZ44Wg25kvBNF7nJqrU6V4G1J/hrZoYKLiOqrF6b32ue4aUYVXniZkCuPQD0Dbpec82V/BxaacW1hqsMBPh9OG0ks4Y+v2dR44q0iaP8Ppw46apLvZifkxrx3gMAQzCIjpGIujAxGoCZqoqMz/3cUtjlrrdfr8cVtxlJ4O2StFaG3gEJIYQoBS1AQgghSkELkBBCiFLQAiSEEKIUFrUAbd++HZdeeikajQZWrVqF9773vdi/f/+8Nu12G1u3bsXw8DD6+vpw7bXXYszYiBVCCPHaZVEquD179mDr1q249NJLkaYp/vN//s/4tV/7NTzxxBOo1095EN1yyy343//7f+O+++7DwMAAbrzxRlxzzTX41re+taiORfUm4ni+wqlt+IcxpVrfEFc21QcNxZOh2sg6rnpk4vgobdsx+kdVegBWvf58Wn/Dxte5x/4nrmIZ7/E0zyzn6jC/cBUr/X28bc0wtwtDrmwKDdUP86EKSGIpAGQ5VyX1Un59asQjDQDAPPKMY9f7ucpqssP9BCdm3RTa8We4Our4wWdofbDClVDnn8eTVdeuHXFqU8e4/1xrnNeZr+GpX7jjyVI+di/kCbyBx+dKpc6vz/BqV/E2YNyzsZFOWvQMX8cpV8HXmuL3JlN7AcDMJG/fafH70KP3hHX/8PGkhsqsZ4wzJp5/lm9cnvJrnxmvGRA1ZrU+QNumqXuMID+99zaLWoAefPDBef9/zz33YNWqVdi3bx/+1b/6V5iYmMBdd92Fe++9F1dccQUA4O6778a5556Lhx9+GO80TCyFEEK89nhZe0ATE6e09UNDQwCAffv2odfrYcuWLXNtNm3ahA0bNmDv3r30GJ1OB5OTk/N+hBBCLH9e8gKU5zluvvlmXH755Tj//FMfJY2OjiKOYzSbzXltR0ZGMDrKP7bavn07BgYG5n7Wr1//UrskhBDiVcRLXoC2bt2KH/zgB9i1a9fL6sC2bdswMTEx93PoEP+GuBBCiOXFS7LiufHGG/GP//iP+MY3voF169bN1VevXo1ut4vx8fF574LGxsawejW3nUmSBEnibnjF9T7EC+q1btNpB4B6WFhhYlHMN7/bUydpPQvcYxd8fxZdIlgAgClDtOAZBxp544VO7fxz30jbrh7gAVRHDvEN3amTrmghy7kHSKdj2HoYliGBx8eTEOsRK9grIxuagH3OC6PvRer23QqeszaFKwW3xblokysUOHbgMdp2/cbX0/rQihW0Hlf4ax494AbYdSe5AMUv+MZ6XONzxSfikdzjYoPCCHr0DR+Z/oEmrQ+NrHVqiTH2MOTHzow51O2648+Mjfws55v2qWFbVO3jFlcR2XQPDaGNZ9wn3Ta3A7MEUl0itPGMgDlrjnuGeITZ/DQGuVgHJJCu1eJWTs4/Pa1W/0xRFLjxxhtx//3346tf/So2btw47/cXX3wxoijC7t2752r79+/HwYMHsXnz5sW8lBBCiGXOot4Bbd26Fffeey/+/u//Ho1GY25fZ2BgANVqFQMDA3j/+9+PW2+9FUNDQ+jv78dNN92EzZs3SwEnhBBiHotagHbu3AkA+OVf/uV59bvvvhv//t//ewDApz71Kfi+j2uvvRadTgdXXnklPvOZz5yRzgohhFg+LGoBKqwP4n+CSqWCHTt2YMeOHS+5U0IIIZY/8oITQghRCks2kC6u1BAn8+0t8voQbesFrnomSriKx/e4JYXv87XYY4FaBVdqWeoWL+THnjVUTMcOPOHUmmvOpm1H1vEQr5ENZ9H69An3NY8fepa2HTvKQ7xaE7zf7X6uYgJRToWGIg0wLHpYMCCA3FAxMSse6xoXmWGB0uJzZWTQDStb3f9W2nZi3LjGRrDZ8UPHaD3vuKoiwykJ1Qq3RLJCGlNi05KBKyAz4xw2htyAOQAYOYt/ry8h9jqhEXYXGlY8M9NGwB5RwVl2WJ5xEhc+e+aO3TMC3JgdTchVh5akc2aSK3FbRiBd5LvH8RqGUs14r2HdE2Hs2vwEMbeP6nbZOTm99zZ6BySEEKIUtAAJIYQoBS1AQgghSkELkBBCiFLQAiSEEKIUlqwKzo8qCOL5SpQw5iorpimxvrGUG55QyLjfUqftqo98wwytYCFoAPIeVxRV69xXqtNyVS9jT7vKOADoa3LVy+A67kFWH3bVSuNHnqVti844rb947Dlar8SGwpCEmFkeVCCBeQCAzAhTM66FT/ypPMMPa3yMj2dqhvclJ3+3dTvcx+vIsz+i9Y7R3rDZQ1x1lXeeoVSDoSbzIq5i8lggXc8434aSbsUqNzAPABr9PMQsIOqrap/hVRfwwMRe11Cjhu493urw+7s1y69Dp8WfE1MnjtN6SFRzXsHPd4+qxoDJkydoPU+5r1rUz1XBDM+aE4aHH8j96RvedpXQvT6FOZMXHPO0WgkhhBBnGC1AQgghSkELkBBCiFLQAiSEEKIUtAAJIYQohSWrgouqdUQLPK2KlCtTel1XJZK2eFpiSJL+ACA3ZHNh5CrvPCsVkqiJAMAr+GumKVfDRMRTzlKrTE9w5UxqnKvGkJvEOXnsMG07dogruFotrhyqxHw6NYjyLiBJswCQBFwZmBpJqdbfUFnmKsSKHj/G1PHnaf3EGPdxA1H1dUkCKwAU4GqyxtAqWk+J55tVDwM+35I6V55lhgdZhyjEMp/7yfX3N2m9WnNVegDghdxTzSfKKaYuPHUQrr6KK/zYHjkv3vg4bZvl/Lqlhj9g1/CUi0jaLPNTA4DWNPdY7HX4sfOcz6GUKHqt+yQkz0gA8GN+DuPEvf5xhasUZ8gzKDVez3n902olhBBCnGG0AAkhhCgFLUBCCCFKQQuQEEKIUtACJIQQohSWrAoOHhxjLEup5oeuUq2acB+mgCWcAoj6DRUTUQ6ls1zFks7wRMO81+btDU+ojKhbKvV+3jbjJ6VteFwlVXf8PSPlsWuo9CxfqU6HjzOccb3t6g2udqv28euWGD6AoeHvlmaucqo9xVVtPcOrz7Kfy4jSyPMMBWCjSeuekQgbGePxauR8Gd6DbM4C9lxJSQptbCgam4OGt5vhE2YpweC7xy8MtWiPeCMCQNeYb2w+F4b6tUrUawDQbnEV1/QUV532j6x2apYCcHZinNZ5sijge3x+BiQJujMzSdsi5deBqXwBPoe6bcMvs+VeB1Zj6B2QEEKIUtACJIQQohS0AAkhhCgFLUBCCCFKYcmKEFoTJ5EvsB8pjE3xkNhGFEbgWVjlm99hxo+dE6uOgFjlAECc8I2+1LCuybunH0rmG5vWYcTrmWE7k5INd8tepGKMx8qaMm1NUnfzMjIsQKLIeE1DgFIQyx0ACIgwJbXOiWGBkhrnJUjcY4cVbl3jB3weFsZ8szbcs657DoOI375+YtgZGWKYLhn/yJo1tO3Q6rNovblqPa1HFUMMRObzwvv9x1jiFo9YIgEA01q0pqdoW9+wSkpJECUAxBF/zZCMh4mJAGBmiouY2rP82tfr/Bwyuylk/DW9iiU24OP3iGijKPj9w0Qfls3YQvQOSAghRCloARJCCFEKWoCEEEKUghYgIYQQpaAFSAghRCksWRVct92Gt8AOwgplK5j6quDqqIQomAAgNRRpnWmiTMm4KscKzMsMRY2lQGEys9BQR9UGhmndN6xhZiddK5HcUGQxZQ8A5Ma5bRn2G7U+10Yo9PmxfUO96BmWIVZYF1OZZYa3TrdthBdGvC8+sSKq1rmli2eM0zrngHFuiarIslDqdbgdS8fI9Fu5yg0pbA7xeVWp8nHmROkIAMj4PMzhdsa01iGBeYCtaGVUjMC8tM3vq4ph0VMbcM8VAHRa7r1fFHzskyeMoEPDQml2xgh3y0adUiUxFLqGtVKWGUGC5Fnr+8b94Ln3lWcohZ1/e1qthBBCiDOMFiAhhBCloAVICCFEKWgBEkIIUQpagIQQQpTCklXBZYWPrFigIDIUUl3ioRRXuNfY1Mmj/Bgz3CsqCFxvsopxbBg+ZlHCFTV+wJUirL0V+JUbXmiW71l7Ztxta6iPajXubzZjhF5NzXIVYL+h1mJYHnZBxM+Vb6jM2i1X2cZ88ABgdpqPv1Ll42cebFHIFZqh4YVWGIrOuDFI68mge146xrmaGB/nx2jx65YQn7DcUGhOnTxO6+EUf81KHw+wi4iqsTBUViy8DrA94nLyd3XVmMs9S61lPGt6Ha6WbRGla8oUtABmjfskM+ZExehjkbrjT1v8ulXqTVrvtfhzr0Oeh5ER8hmR+yFN+X25EL0DEkIIUQpagIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpLVwUXJsgWpFqmXa56Cauu0qbwuXIkN0QvUT9XqsU1128qNvzkDCEUIsOHySu4OswjKY2F6bVlpHwa54r5mDUM36/c8rYzvPDqFSPNlB3bUh8ZSqjQUBj6nuUp5x6/yPn5jg3Pt8RQwSV9rn9WZHiHRTWuAkPIlZS9hcrPH9eJH1j7uOsFBgDdNp8rgc/TPFsdVx3oj/PUzk6L+5IlRiJsx0g5jSvuOfQNv78w5nVLqTbbduen5e1m+cklJFEXAKqGorN78qRTmxh7gR+7aozTULpWrVRZMvzIUNYi4p5v3R5vzxJNkyrvX0L6lxfGw3ABegckhBCiFLQACSGEKAUtQEIIIUpBC5AQQohSWJQIYefOndi5cyeeffZZAMBb3vIWfOxjH8NVV10FAGi32/jwhz+MXbt2odPp4Morr8RnPvMZjIyMLLpjLb+CzJ+/UVtp8I00top6RmhaYIgTkPNNs27ubvL3OkYImhEohVlDbECODQCRR8K6priFkGcIBQLL6qXubopX+/lGeWoEtaUp73enzc95QULjwpBvWscJ3xRm1i0AEER8Yz0mwWlJhW9EtwyBQ63Z5PVBdz53U2PsARcb+NUhWk9JsBkATE24ggNr/vQNcjsfKwQwDNy5Uhjijl6XCxwyw+bII4IAAMCUa/USG9en1tekdUuYwsLUWjPcFsfqX88IL+xl/B6fIeOZmThG2w4O82tfJ8GNAFBv8PuThTdaW/8eCY0DgHrTCB5kffH50T0SXMlqjEW9A1q3bh3uuOMO7Nu3D48++iiuuOIKXH311fjhD38IALjlllvwwAMP4L777sOePXtw+PBhXHPNNYt5CSGEEK8RFvUO6D3vec+8//+zP/sz7Ny5Ew8//DDWrVuHu+66C/feey+uuOIKAMDdd9+Nc889Fw8//DDe+c53nrleCyGEeNXzkveAsizDrl27MDMzg82bN2Pfvn3o9XrYsmXLXJtNmzZhw4YN2Lt3r3mcTqeDycnJeT9CCCGWP4tegB5//HH09fUhSRJ88IMfxP3334/zzjsPo6OjiOMYzQWfm4+MjGB0lH9hDgC2b9+OgYGBuZ/169cvehBCCCFefSx6AXrzm9+Mxx57DI888ghuuOEGXH/99XjiiSdecge2bduGiYmJuZ9Dhw695GMJIYR49bBoK544jvHGN74RAHDxxRfjO9/5Dv7iL/4C73vf+9DtdjE+Pj7vXdDY2BhWr15tHi9JEiTE2ibNPfgLlGntlCs5ktBdR6OIq6yYQgYAioyrj3rESqQ1OU7btgybktywy0kSfvpXDLkqGc8Yz+TRw7Setbnqp1J3VWbN4ZW0bRhzBVetydsPtA113DQJveKXEkmV244kFa6OQ87VVxVi9RKZajeuSgqMcz7+oqtIJEI/AEB1kKv3/Jj/g7HD3L7l2MFnnFq9wudPpWaE4Fl2RpF7ndMuvx8M9xt4vnECjBOTkntiZpLb/1iBiZZ1D1N6ZoaVVdd4pmRG0KOhc8U4uQ+tsLe+/jfQer3BVXBxzK9bhdiEpT0+Tsv5CsY4O7OuAjYy7JYKEl6YWTfEAl7294DyPEen08HFF1+MKIqwe/fuud/t378fBw8exObNm1/uywghhFhmLOod0LZt23DVVVdhw4YNmJqawr333ouvf/3reOihhzAwMID3v//9uPXWWzE0NIT+/n7cdNNN2Lx5sxRwQgghHBa1AB09ehT/7t/9Oxw5cgQDAwO44IIL8NBDD+FXf/VXAQCf+tSn4Ps+rr322nlfRBVCCCEWsqgF6K677vqpv69UKtixYwd27NjxsjolhBBi+SMvOCGEEKWwZAPpOnmBfEF6XN1IfGPhSYWh7sgtFZxhotQlaqDZWa4wSz1+OiMj9KowvJU6hetvNtTkSsJahSuBxl94mtZbU+NuP4y/Q6IaV+X0VXm9M82943zin5XEXKkVG/VKg/ubZe0ZWi+IR15kqIkaq/h3z3pGqF+PqLJ8w8MuqHOFXc+Yn23Day0kfU8q3AcvqXL1YhQaKjjm5WXdJ7RqKz1TQ30WxG7fK338HFrKrsAKpJtww+EiQxnInh0AEIb8Xu6Q+wcAaiS8MOjbQNsmxj3rG+fcMyRsMQnqCw0PNuvaW9cnIw/EHlOzAvDJc8wKLnT+7Wm1EkIIIc4wWoCEEEKUghYgIYQQpaAFSAghRCloARJCCFEKS1YF1059ZMH89ZFYvp1qS5RDhaHuiAquemlPusoZAOhMu/EQsxM8nXRmliuy+gcMr7GAq5imqq6Pmb/hbNp2oI+re4Y3vJnWvcxVcMUx93hK+g3lGXi/DQEXkuSIU4tCrtSCoST0I56WaWVAplOuCi5pcA+7rpH+2Wpzn72UqPoa/StoW0sdVyEKJgBYv/H1/DXXuCrI2AidzI25X2RGnaXq+vwaF4Zc1ErJzY17wsuJsss4dhDyvpjJvMS/sX2cp5NayrtuwY/dbnGlJ1NMdg1lYIv4rAGAH3ClWpDzB1+PKHSLjD/fMsNPz1R6tskz1ePKTUbbSsJdgN4BCSGEKAUtQEIIIUpBC5AQQohS0AIkhBCiFLQACSGEKIUlq4Jr5R7SBeqPosNVGBMnXKWa3x6nbb0O9zOyPMUaxOMprrkqNQCoG2q3SsIVX5mROpmSPo4+9yRti/VcNbVyBVewVaojTi1JjPTYgE+P3OdqneHXuUmUADARuOOfep571YVGwmnWMlQ1hk9Wkbrtk1XreNseP3ZxYozWmbdfp2MozKZO0Hqlr0nrQ0Y6rU/GaSVl9gx1WNtQpGVECZUb6qisx+dst2d4wRnBmCzldMZQhwXGPLQSUbPMfdFel3uTZSf4OckN/7lZoooFgFbHPS/WORkYatJ6zVCdpoZv4My0myAb+fw9RXfGeO4xBSR4kK1nxBgHRNGZG2q8hegdkBBCiFLQAiSEEKIUtAAJIYQoBS1AQgghSmHJihA6nR6yYr7XyFSHbxh2Zkj4mLGJmnf5hl4t5pYc1T7XAqbRx0UF9T6+Cc8CvwCgO8s3BqdPuLYhUyRkCwCOjXK7mHp/k9bDhNidGBvoHndAQVwzxt9Yxf9B6NoFjR7j1igToy/Q+uyJ47SeDPGgvr6Nm5yaV+ObvN1jh2i93eNzpVOQ69njYojQ2EAOfd6+WjE23NkxYt42IcIZAKjWuXgmD932PWMDvdfiYYztSX59wtjdKAeAmSl3Pp88zo+R5Xx+xlUjRZIE1dUNq6S0y4UPKfizJjAEO+i6m+6RYXGVGhY93ZYhFDBskViAXWa8pbAEBLERlkmfWcw+CQDIXDa0J+4/Pc12QgghxBlFC5AQQohS0AIkhBCiFLQACSGEKAUtQEIIIUphyargWt220zlLmeMTzUXbCHHyDUVJwwimWrVmrVMbGnHtbAAgrhqhaYZ9SW+W23rUq24fKxVuOzI1ydU6Lxw8SOvhG891ao0BIzTNCtKL+Dn0jOCw2pCrjmu+3lWpAcChbz1L63HElVBrN11G68nK9U5t2ggSnDrJFXm5EZDmEyuiWp1fn74av8X6ary9FbroFa7SyMv5/RAYx7COzUL9qo1+2jIb4ErCVpOrEbvT3IoofvF5p5YYFlfTk1xJ1+txu5ecnBc/5EpUv+DXIfYNhZ0xxzvE/qgwLJGmxsdpPQm4yqyvf5jWo5p734bGxQ9DPg+tUMyIKCyDiKv6WAieH3HrI6fdabUSQgghzjBagIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpLVgVXFD6KYv76mBreXOi5KjhDgIJV/Vzx9YZzz6P1tWdvdGrVKvdC8w1VUmaodbIGV/1UiSIvMXzmwsNc7Tb2wrO0fogEm61/01tp2zzggWdx1fV2A4Ag5A5QReGel2jV2bRttup1tB4RTz4A8BtclTVxzPXIa03wgLlOiyt22HUAgFqfe936DNVYf5MrCUF8vAAgNRLceiQwsWLMiTw1Qv1SKySMjL/Dz4mX8HOSWH5ljSY/DvEgCyvcky8hgWcAMH6Se8f1uuR50DW83UJ+7DTl18cjikEAKIhisgBX3qUkvA4AMuOh5Ruq07hC7sOcX2PDxY3Z5gEAAnLvR4aSkIlF09B4AC9A74CEEEKUghYgIYQQpaAFSAghRCloARJCCFEKWoCEEEKUwpJVwaVpjsKfr2bxLMkGUYmMNHk650Xnv4nWN7zOVbsBQIV4IvmGmqgwEgO9gCtnAkPdE/pNUuMKFPMCGmqYiYlxt2akjXaJuhAA4ipPm7WuT0HUgT0jQbS6Yh2thzWuvBs/Nkrrvda4U7O84HxjWiVV7vlXb650av1D3K/L8ubKDWVkUrHau6q0vMevQ5bx+ZYZ7WfHXXVgu8tVTB1DHTa07o20Xht0zxUA+GTuhyOvo21jI83Ur/E04Inj7pyYHefXfnqSJw17JCUW4CmkAFDrazq1mSnuYdc1roMhXkSR81/MsL4b6bFV4hsHAPU6rweRq4ILY66KTTtuqqxnJP4uRO+AhBBClIIWICGEEKWgBUgIIUQpaAESQghRCktWhJBlGZDN33wrMr4x2iBhbRe+lVvrrN9wFq2HHt9wR9fd/GUBTIC9WWj12zc27Vngm29sFnrGa3pGoFZy1N2gnRnnG/lW/zLjVPlGgFvWczdGO7NTtG17htenT/A+Zsa5Tbvuxmi9wUUfgyu4YGX4rNfR+sAKV5yQVPimdWYIU3yPbxb7xvWMIrfvUydfpG27KX/NyTFu29RH7KmsB0MG3r/x5/6J1idGn6X1qM8VFtQGudjAM4LQ4uE1tF5Mute+iKZp21rCr8PEDG9fNayF8ln3OdElm/MAvx8AYHKcX89KlY8/SVxRQGzY9gQBv6JZxq9nb8oVOGQpfwbFiXtsL+CiqYXoHZAQQohS0AIkhBCiFLQACSGEKAUtQEIIIUpBC5AQQohSeFkquDvuuAPbtm3Dhz70Idx5550AgHa7jQ9/+MPYtWsXOp0OrrzySnzmM5/ByAi3NbHwkMNboLgZHOAqjAvPO8eprR1p0rZZi6us4sQI1CJqDqZSA4AiN1RjhiuFpY4rCvcfMDubU33h9hhRzJUzjaYb4Jbn3KakNX6EH6PGg9ACI6jOIwqcPOVKIGucs1M8IK3TsoLG3Nr6c95C265ex8PxqkRlBAAxCSRkYwSAzFBTtWe4QmpijIeytdtuiJll9VL0+DlZvW4DrQ+sXO3UWtO83x5RewHA9Djvy4nnufKumz3n1CrEzgYAGsP82dG3wu03APStIuq4hM9Nvz1O68kUvyempvnzwyNWWVwTCng+nyvdLlfXWnZBQb8bghgZvlJ5znvTmp7kxybhc5ERa5cSWylWY7zkd0Df+c538Nd//de44IIL5tVvueUWPPDAA7jvvvuwZ88eHD58GNdcc81LfRkhhBDLlJe0AE1PT+O6667D5z//eQwO/stf1BMTE7jrrrvw53/+57jiiitw8cUX4+6778b//b//Fw8//PAZ67QQQohXPy9pAdq6dSt+/dd/HVu2bJlX37dvH3q93rz6pk2bsGHDBuzdu5ceq9PpYHJyct6PEEKI5c+i94B27dqF7373u/jOd77j/G50dBRxHKPZbM6rj4yMYHSUf5N9+/bt+JM/+ZPFdkMIIcSrnEW9Azp06BA+9KEP4W//9m9RqbgbsS+Fbdu2YWJiYu7n0CG+CSuEEGJ5sah3QPv27cPRo0fx9re/fa6WZRm+8Y1v4K/+6q/w0EMPodvtYnx8fN67oLGxMaxezRUrSZIgSVyfq+GBPoTx/EVu00bu/bSy6Sq+8jZXGcUkYA4AAkM9EpHgLM9QgxRGoBQCbp7mhbwvPjl+t83VYT3Dly5KuAouz92+VDtc2dSddYPKAODEof203lz7eloPQvePlcIYe24EfvUMj7TZWa6+WrnSDYjra7iqIQCoG/Ww4OfWa7tKqFkjwO3FYydofWKcf9TcmuR+YEykOTzcpG1rsat0BIAVr9tE6xkx98uMdLSpca7IOjn2PK0fe+EZWq8T3zevYsyJNp/LrWOGn16VqMMSrqCdmOXHbre4l1lhKNUyouqsD/DrYAUgTr3IlXezhtqxEruTolJr0La5ocnzDC846uVW8OdYELj9CE7TC25RC9C73/1uPP744/Nqv/u7v4tNmzbhD//wD7F+/XpEUYTdu3fj2muvBQDs378fBw8exObNmxfzUkIIIZY5i1qAGo0Gzj///Hm1er2O4eHhufr73/9+3HrrrRgaGkJ/fz9uuukmbN68Ge985zvPXK+FEEK86jnjcQyf+tSn4Ps+rr322nlfRBVCCCF+kpe9AH3961+f9/+VSgU7duzAjh07Xu6hhRBCLGPkBSeEEKIUlmwi6toV/YgXpEw2G1yxUhAlRxhy1YdRhm9IUzyiyvINpVZh+C3BEIRYqYE+8ZWykjIRcAVbr8VVgCy1NTK87awkxqkx7hH3Ys/1KwOAqM785/h4ui3DO212nNbjiJ/DBlG2Rcb5LozkSnhc8dQh5/b4Ua5eOzH6Aq3X+pu8PsDP+UDTHU+fkSBa6eNKqNDwQ0tJEmfH8LCbmuCqvoz4FwLAWRu5MnJw2FUpWsqp3Ej3nZ4ap/WTzz7l1CxnsmDFRlqPBtz+AUARc3/A/orbl3FDGTgzZaQBt9u0Hnin71NpqV8Lon49dQxDFUxUqoWhgmOX3pgO7uufXjMhhBDizKIFSAghRCloARJCCFEKWoCEEEKUghYgIYQQpbBkVXAjKwaQLEjY9A2zNZYCGBpJofCteFJez4knVq/HPahgpHkuTHb9MYHHT39KlClF6HrSAUBgKJvCHn/NlCgGvYCfq6TO/bP6+rlaZ2qaK6SmJ1yPK8/nyh7P49ehaSi+msMraX3VqlVOLTEkkFmHjyczvOBGDzzt1GZb/BiNPn59Gv383EYB72NjaMipLbw/5o7R4B5kHZKqCgCzbXeck5NcqWUlXQ4MNmm9Ghvefm03tXXKSFtttwyvwpT3pZu6cys37s3jP/wmrfed/XZa7zd8AwFXIWYpHVuG0pOpXwHAChftEQ8/BEYqs3GuEBrq3677jLP8MkOWeGx4zC1E74CEEEKUghYgIYQQpaAFSAghRCloARJCCFEKS1aEEHs5Ym/+Jlvg8U06a3OMkRkCgp5hVdHL3M1S37CuYeF1AOB5vH8FCXL653/hVnwjvC7kxwgrfIOa9dA3+uEZQo7BgI+z2s8tbTJybvPUCOkzLmXNsEZZuXY9rddJ8GDVsKixbENeePJJWj/81A+d2oo1Z/F+9HFBQJwYwg/D/qjSaLrHqHEhQ5rzAY2/yMPkDvzo/zm1k0eeo239gt8/VWNzvt3i83b8mGvnNHXiGG3bMaySmlYgH9n8b7f5priRgYfDP+DihN7rL6D1FcOuSKTWcGsAkJENfgCYifk9257l4YWdtnucriHYqFTqtG7dcBkJusxy/pwoiDUZqzH0DkgIIUQpaAESQghRClqAhBBClIIWICGEEKWgBUgIIUQpLFkVXJ7nyBeop5LYCGYi4Um9Nre78Ii6AwByojwDgCByFV+eoTzLiG0PABiZT2bAE4jaj40RACqGXY7hsIE0cceTG6qp1AiYSw0lYd41rFHaroqpO8utXiyaq7jKbNCw4gmJJUlqKH5Gf/R9Wp84ZoTJNVw1Xa3KlYGVKle7VaoVWk/6uJosqroqpsKwM5o4wcPxnn6Cj3PsoBvglnW58ixJjHvQmPvw+XnpZu79lhn3oB/yc9jp8PmWEBuY3LjvawmfE2tW8usweewZWh8nFlKNphEY2OBztm3YOXU73EZofHzcqQ0McuXdwnDPH2Pam8Vu+5A8CwEg7bjPCVajr39arYQQQogzjBYgIYQQpaAFSAghRCloARJCCFEKWoCEEEKUwpJVwQVhiGCB8ssKmcs6rv9RYagwrHA4WL5smatA8QzVWFjh/QtiXrcCqApiTuaDv2aRG8oh41yFnjuerhHIVqT8HOaGN1fe5cfxe249Cvh1aKxYR+vNkbW0boWydabGndrTjz1M26Lr+v0BwPDICD82UfUZAi7zF4VRt9RKBVFGTs/y63PoWe7j1prhytAa8Z+rr+IKrvrAAK1Xa9xrzAo7XLHSVWvNTHNlZGGEyXUM37OJCXecfszvnzoXI2KEKB0B4OQMn7cTJIwxM/z+qkN8XmU5V+qdPMk98p4/dNip5Ubw3JvPNzwGiSoWAAKmGLWUdESl6IcKpBNCCLGE0QIkhBCiFLQACSGEKAUtQEIIIUpBC5AQQohSWLIquLhaddIhM6KmAoCcqWEMBVdkpJnmhjouiFzlR5Bw5RUMVZtveL5ZJ78gAqm8x9UtyHm/C6OedVzFV9biqrbuzAQ/hqG0yYxznhFFYmWA+2H1D/F6VDHkSoZCqjvlqpICnyuhGiPcZ65/iKewTo0fd2qViF/NrqHGHFrHj+1VuLdfJ3fn1nMkyRQAThx5ntZhpP6yBNF6P1eB9Q9wj7S+Pq6QCg0Pw07NvZ4nSIotAOQF/zs5TbknYavzrFPrzfBUUWT82IHPVYorhrkKcKDffSZ4xrOm1eNqxKTJlZ5rN/A5VCMJv71Znno7PeHeDwCQGinO1vOD9oOk4VrXZiF6BySEEKIUtAAJIYQoBS1AQgghSkELkBBCiFJYsiKErNtBFszfeM1muWUKyIZXAL7hmqW87sVcWFCQzcgi5WKIIOEbtJYVT2GEZBVdYi2U8s12a7PPsuRgwVy9Nt+g7bb4Zqn1d0tgbGhGZGO9f2Q9P3LFsnThU7UgogoAaM+6Yxoc4TY/ljDFD40Arp67QRvUeb+bq9bQelDhm/zdNr+ez/zoSaf2/FNP0LaVhJ+rxgB/TSYgaPTzuVwj4gEAiBNLJMLvNyaq6TPC+Fodfk64pASIImZbxOd4NeTnpPC4CCGJ+NxvDLjWRVbQY7Xg12emzTf+k/Xn0LpXuOKEVsjPd2o892BYFC0MAwWA6QkucAiI7ZclvlmI3gEJIYQoBS1AQgghSkELkBBCiFLQAiSEEKIUtAAJIYQohSWrgktbbfQWrI+FoSrxfTIMz2hrhCqFRj0igU1xnStnQiOUqzD0OlmbK7jStquyM0Q58HxDkWZYoPRmiGLQCOOrNgb5i8II0jPsS6qNplPLDFEOC7cCAI8EsgHADLHFAYAgcM+L51vH5p3ptnng2dTxI05txRpD7UasnABgYpyrsl549llaf+bxfe5rjnDbotXruMIwDPg5rFXdeh+x5wGAwrDF6bZ4mJxxy6JHzm1nkqsuM5+rEf2QK++aI2c7tSLkKte6kUMJ476KEv4PYqK881ioG4DYCCMMDTunyVmuaB1cf55T8597nLbNM65KS40b0SP3cmwoVLskiJLVGHoHJIQQohS0AAkhhCgFLUBCCCFKQQuQEEKIUtACJIQQohQWpYL74z/+Y/zJn/zJvNqb3/xm/L//dyoYq91u48Mf/jB27dqFTqeDK6+8Ep/5zGcwMjKy6I6lWYrA8TPj6hGPSMT8iuFLZijYkjr3oUpIEFpMlHEAEBhqt7zDA98KYzzsKKHhs+YX3D/KN46NuuvL1mUqQgDttqWc4a9ZNc5hQZQ2Bbi3XRhzZVPr5CitezlXCFVq7jgLQ5HlGz5zk8dctRsAVKvutShCrhB6/rlDtH7kuQO0PnbwaVpvNt15O7KKqxQH+rjaLzbObUTmVm5c46kT/Dp0W4ais8evc2fWVby1DNWhF3LlWWaoMWvk2kdruA9gf4OrFPMuv2etAMiMeKcZQlTExDsNAHyi3ASAKcODLWu5EzqsGsrVzou8bHgP9oiXZLWPh/ExtV8QnF6g3aLfAb3lLW/BkSNH5n6++c1vzv3ulltuwQMPPID77rsPe/bsweHDh3HNNdcs9iWEEEK8Blj094DCMMTq1aud+sTEBO666y7ce++9uOKKKwAAd999N84991w8/PDDeOc730mP1+l00PkJ59TJSSM6VwghxLJi0e+AnnzySaxduxavf/3rcd111+HgwYMAgH379qHX62HLli1zbTdt2oQNGzZg79695vG2b9+OgYGBuZ/16/mX6IQQQiwvFrUAXXbZZbjnnnvw4IMPYufOnThw4AB+8Rd/EVNTUxgdHUUcx2g2m/P+zcjICEZH+efGALBt2zZMTEzM/Rw6xD8zF0IIsbxY1EdwV1111dx/X3DBBbjssstw9tln44tf/CKqVb6Z97NIkgSJsakvhBBi+fKyvOCazSbe9KY34amnnsKv/uqvotvtYnx8fN67oLGxMbpn9LMofM/1FutxxYZPFrCE+I8BQGL5uBnKlIApcAwlTGH4z8Hnah14hhKsRvpoHKPI+DkJfMMLLyBpqznvR9dQ7yV1robxDcO6zuyEU+s/6/W0bdrmfmDdKa4EqhreXFQZaXihtab5vmOcGB8QDLmqzmNH+Lv85574Hq1babj1Gr8l6zV3fmZGGmzW4uek8Pi87ZI5dPKke80AIDMSeFvT3Atu6hj/RINdi0rfEG2btvi192NX7QYAtaTp1Dzj2lerXBnYNVSn1jhRuCq4vMNVfaFhkGepYquGonf25AtOrX9wFW07fZx7s42P8evDvOMsf8AocX32fEsCuLDdabUymJ6extNPP401a9bg4osvRhRF2L1799zv9+/fj4MHD2Lz5s0v52WEEEIsQxb1Dug//af/hPe85z04++yzcfjwYdx2220IggC//du/jYGBAbz//e/HrbfeiqGhIfT39+Omm27C5s2bTQWcEEKI1y6LWoCef/55/PZv/zZefPFFrFy5Eu9617vw8MMPY+XKU7bwn/rUp+D7Pq699tp5X0QVQgghFrKoBWjXrl0/9feVSgU7duzAjh07XlanhBBCLH/kBSeEEKIUlmwiat7rIl+gXAkNz67qkKuysxJOfSOl0DcSEJlCrMi5Eoj5QZ06OFfg+EbCYE4UNRlJSQWApMqPASMBEWT8lkKoYikGDdl82uWqn7jqqpUqDa54mhp7ntYBfm4tZVuUuOomK1HXUgzWV3D15tiYm8I6O8FVY9UKn7O1Pu7Z5RvprI1+12evVuMpn4Gh6Ox0+bydJWrHmQnuHRYQxRMApIYnYWVgBa0Xhav4ygyzvuog95JsNI1jM484ck8BQJ5ZClA+nk6Hn8OEPG+Yx96prvB7s9fiaswi5eel1nDVqL5nKFfXv4HW85Q/VzozJ5za1Is8fXhw9VlOrTCUwgvROyAhhBCloAVICCFEKWgBEkIIUQpagIQQQpTCkhUhBFGCIJq/iVc1Nh1D4kMXhJa1jjFka5OS1K3NbC8wPO0M4UNuBL5lPXczPzY2NC0BQd7lm6sg56Vi2Bb5xoZrz7AY8YxzWBlwBQeFISooOtzqxHI56pGwOwCII3dOFIa1kLWZnXt8rnj5Ubdtj1/LlWvdDVoAqBgimdwI2Gs0XBFCw7BGaU2P0/rEJB//1KQroLCC/iLLbcrn9j894zhxxZ2HQczPSUICAAGgWIT1k/W3dmiIJybH+blqzXCrKBA7o/rwMH9Nnws5Koa4p23YPBVE9BPW+DkMfT4/h9ZxS6yjB9z7sN3iY+8QgRSrMfQOSAghRCloARJCCFEKWoCEEEKUghYgIYQQpaAFSAghRCksWRVcVOtHVJ2vFomNILQwcm1XDOEZckP1Yq7FxDLEt9RuRlhXd5arR7KUK9UipoYxbErynqF2MxRpDEt9FBlBdci48i412rPrlrW5ki43zkm3Y4T3xTxQjJ3bMDRseypclTQ1ya1RmP1PjQTGAcCKNev5MWCEkhl2TnHoti+MuTx6xFXpAcDYYV6fmXJtV5rDXBnYJPfaT+uLZ9hnMecrww0LOVGFAsD0LFdM9sjc6hiK074mt4SKAq7qm00NG52Oe326U/waJwP8OVY1nm9VwxIrTV2FoR9wZaBnqE7D0AjBa7jBdq0pPn9myfzpdAwrsAXoHZAQQohS0AIkhBCiFLQACSGEKAUtQEIIIUpBC5AQQohSWLIquLBaR1SbH7ZmKduYAidLuSonM9RhViBdSBRPeddQwsyM03rX8GWzFF+9juujFAw0aVvP5yoWn4VyAQhCou4xPM9iw6/MUmpZijSfBKR1Jl3lDABMT47TuoWfuGodAPCIeVxhqBdnZrnKil0HAMjJua3VuFLJ9CQ0QuM84ikGAB4JQTx5gp/DI88fpPWpca7qm5066dTyLlduxjG/TwZX8etQrboedgAQkWC7dotfh9RQnnXaRjAkUZ2+eOwYbVsYz4PICIu0HkJd4ps4U/D+wQika4R8flZqhkdc170/WTAeABQF73d69Aith2T8nRnej2niJdg1wg8XondAQgghSkELkBBCiFLQAiSEEKIUtAAJIYQoBS1AQgghSmHJquBQ5I6fWZ5x1ViHeSJZKrDAWnO5mqxLFDjpJFfUZKQfANCa4uqjnuGXVOtzPaFqda7KScHVfnHFUKR5bt1K4TQ94og/HgB4/ulPpzZRXgFAbqjAwoT3JSDJpwCQEV+6aUN5lxsKoZmTxnUm6adxzFVtlidfkfHr5hspn/Bc9eLxY3w8rWnukZYkljKy6bY1PMKimF/jijHf+gdX0nqRu+OPY+6/1pqdofXZcT6HisydzwNN7rPWIj5mAJCRtFEAmJ7g6sDmKjf5Ns35vGq1+H0fGdet1s99+VKSzOz7XKlm+exNGCra3tRxp5YYXnWdGfc69LqW5+aCfp1WKyGEEOIMowVICCFEKWgBEkIIUQpagIQQQpSCFiAhhBClsGRVcGmRI13gOZbNcDWMR5RDgaHI8owkysBQk+Wzrs+RlTrYM1IXZ8e50gZG6mJGFFJMeQUAXs6VTUm9z2h/+opBz1CYBZYKzmhPFV9GgmaUGP2OuQqw0+PHaZ8cJa9Jm6JjeMG1p1+k9aTqjjOM+LW0VJdtwzcwZF59ADod97pNTnB1ZaXGz2EArjD0Q1fBVm8O07ZVotAEgDDmqbKpoVxlHosw2k6dcBVZADD+Ir+vBofcPiYxV4eNHnyK1j3jb/PASHj10lnSmJ+TKOH+eJYfJcDPS72v6dSM4GRY4t/BVWv4K3bd8bSMVOIeeTb1DEXwQvQOSAghRCloARJCCFEKWoCEEEKUghYgIYQQpbBkRQjd2S68Yn73WMgYACB1N1cLYxMsMixGAsuOhlmjGHYX7RlupdHLuB1LQELGACAnNjKZEYLn1/jmvG/a4pC+WG1Do54bIWuGrUdKxp8YG+WZIYhot7nYYOpFbpfjE6sXKwQOhbFh6vO+5IVbjwyrIMvSJSdzFgAOv/A8rY+NuuNMiUAGAPoG+CZ3pT5E61HsjqdvwBAhNAZp3RJhWCFzHpnjlj1Re4aPszXFr/1ZGzc4tf5hvtl+4sQ4758RJjfUx69zldyHiWGfVekzrkOF3xPWde6RQMtaP79ugSHCYIIaABgYHnFqcYsILQCkmftcDhRIJ4QQYimjBUgIIUQpaAESQghRClqAhBBClIIWICGEEKWwZFVw7dkpJ7Qq6xhWPCT0K/ANxVyFqz5yIwcsJOqW2RkeStXpcjVVt8X7HRm2K0zsZ1ls+Iadj5lARUKymJXRqV/w6VEYli6e4ffBtGRRrUHb+kZYV6/FlUBehSvbQhIQZzqdWJZIJPALAPK2qwbyDAWgFVJ44iixCgLwzD89TustYkM1vIIrnuKEj6dq2DP1EdudWh9X0lnqxZahALXmFlNGdltt2jaq8r4wpRYAZC1yfxJV5Klj8MC8OOEBe5WQK1pZAKSljLTUbmZQXYWr6byeO7csJaEVfhkYSs+E3J9BzM/J7Kx73XxmtUTQOyAhhBCloAVICCFEKWgBEkIIUQpagIQQQpTCohegF154Ab/zO7+D4eFhVKtVvPWtb8Wjjz469/uiKPCxj30Ma9asQbVaxZYtW/Dkk0+e0U4LIYR49bMoFdzJkydx+eWX41d+5Vfw5S9/GStXrsSTTz6JwcF/8Yf6xCc+gU9/+tP4whe+gI0bN+KjH/0orrzySjzxxBOoEKWIRWv8KLIFSpTc8FQLifoqMBRmQcg9kcIKb9/tugqPdpurddrTXKkFQwlUGKFsRUoUKx7/W4EIAAEAufG3hU/UWlb4Vm4oh6zxeMa59UiglqWo8Y3AL9/wAfQNFY9Pju+x8/rPPWR0prmyizUvDMVcQXyyAGDyBPcxmzHCC5Oae277BrmnWMXwIKvWeEBateEqnqoNHjxneQx2Txyldeue6M26SjUr0LHSz/3nKobv2cljLzi1uMbHs2pkFa3XrfETdSUARFVX2ZYb195SxcYFvw/TNm8fhO7cz4xQv67lJWncP/V+d/ydNvf1S9hz3VLWLmBRC9B/+S//BevXr8fdd989V9u4cePcfxdFgTvvvBN/9Ed/hKuvvhoA8Dd/8zcYGRnBl770JfzWb/3WYl5OCCHEMmZRH8H9wz/8Ay655BL85m/+JlatWoWLLroIn//85+d+f+DAAYyOjmLLli1ztYGBAVx22WXYu3cvPWan08Hk5OS8HyGEEMufRS1AzzzzDHbu3IlzzjkHDz30EG644Qb8/u//Pr7whS8AAEZHT325bmRk/hfERkZG5n63kO3bt2NgYGDuZ/369S9lHEIIIV5lLGoByvMcb3/72/Hxj38cF110ET7wgQ/g937v9/DZz372JXdg27ZtmJiYmPs5dOjQSz6WEEKIVw+LWoDWrFmD8847b17t3HPPxcGDBwEAq1evBgCMjY3NazM2Njb3u4UkSYL+/v55P0IIIZY/ixIhXH755di/f/+82o9+9COcffbZAE4JElavXo3du3fjbW97GwBgcnISjzzyCG644YZFdazTmkWRz5d4eYYhmk/83XxDYQYY/l6G11qPKN5Sw98r7XGPNEO8Bz/gShGfqluM1ySpiAAAj6tbCpLmmve4qs8yoPOMY3sRV8H59Dj8b58w4ceAx0+icWrhEbWWF/Bzlfe4Qqhr+Gcxn7nCGE/LSASdnuDqsNRQMQ31u55ltYEmbVsxUnL7moZqjniWWYq0zPABtNRUkTEnssA9L5mhUpx88QitBxFX9dUHXWVbxVAAVqq87hsqrnqd/4HMnjaB5YdmKAmLgN+HWYfXe0SVFhpK45rhJ9c2/PcW+nCegp+ThHgMFoaadSGLWoBuueUW/MIv/AI+/vGP49/+23+Lb3/72/jc5z6Hz33uc6e653m4+eab8ad/+qc455xz5mTYa9euxXvf+97FvJQQQohlzqIWoEsvvRT3338/tm3bhttvvx0bN27EnXfeieuuu26uzR/8wR9gZmYGH/jABzA+Po53vetdePDBBxf1HSAhhBDLn0XHMfzGb/wGfuM3fsP8ved5uP3223H77be/rI4JIYRY3sgLTgghRCks2UC6Xqfj6AV8Y8s5CMmGsyE2sDbtPWMTNWWbscYxMmPTvm0ETVUGeDAVExAsFGTM1Y2NwcKw7mHbpSkJtgKA0AjvM/PrjDoLybI2aM0AM8NKJKxYqklmz8Q3xKOI26vERtgdC7DzQt522rDcscLH4oRvijdXrXNq9X5DVGB83F3pa/I62VifOvkibcs3p4HACPUL6jx4MA5JMCJtCeSGAKdS5RvrtX5XhFCtGte4yvuHnL9mzxIgkTDK6gC3EPINoY0VGpdU+fXsee61KFIueomr/F4ujDnearliE+s6kEtJawy9AxJCCFEKWoCEEEKUghYgIYQQpaAFSAghRCloARJCCFEKS1YFl3Y7jirGs0LJiJWKIUhDZPji5B3DRmeGhJLlvK0hVENuKGoCQznlMYWYZUPkW0F1RmeI1Cg37F9gKH5CQ1FjngB23Qy1W9ewBoHHVVaWepEd3jpXcY2rjGJDreQlrnIqNexSWtPjtN6d4VY8tf4mrTeaK5xa1VCYJYZ60bLLYX+HVhu8H3mXq6ym2lztl+WG5VLkKtj6Glxh1yCBeQAQG5ZDeeE+1kJiNwQAmRH2FhtKwsCYQ0HNPb4VUpgX/L6yLLF8w4ZqYHjEqXVbPM4mMMZfBPyc93pu39OUtw1J+GNoeWQtQO+AhBBClIIWICGEEKWgBUgIIUQpaAESQghRCktOhFD882Z7r+tu9FsiBC90N6iLjLcNSYYGYG9m52xz2RAhdA0hQ9ewkekYG9dtliFjWKAUEd9EDWemaZ3Zd3Rn+TGsTcfU6EtotM87s24/jHPVarltAaBNcpkAwIv59QTZLM58Pic6RmZP27BG8Qp3vlm5Px1rTvQM4Ydhi8TGb72mlW2VG2Y3aeGeK8uyyhIhWH0xRQi+2xcr9yYkVlsAkBrjoSIE43mQtfl8Sw1BTWjMfZDxeL5xDo08rdlZ3hc/5/MwJ4/vrnEdgswQ/Rj3LLue1j3Y6br1H7ctLDXYP+MVP6vFz5nnn38e69evL7sbQgghXiaHDh3CunWuj+GPWXILUJ7nOHz4MBqNBqamprB+/XocOnRoWUd1T05OapzLhNfCGAGNc7lxpsdZFAWmpqawdu1a8+sPwBL8CM73/bkV88fOyP39/cv64v8YjXP58FoYI6BxLjfO5DgHBgZ+ZhuJEIQQQpSCFiAhhBClsKQXoCRJcNtttyExLFGWCxrn8uG1MEZA41xulDXOJSdCEEII8dpgSb8DEkIIsXzRAiSEEKIUtAAJIYQoBS1AQgghSkELkBBCiFJY0gvQjh078LrXvQ6VSgWXXXYZvv3tb5fdpZfFN77xDbznPe/B2rVr4XkevvSlL837fVEU+NjHPoY1a9agWq1iy5YtePLJJ8vp7Etk+/btuPTSS9FoNLBq1Sq8973vxf79++e1abfb2Lp1K4aHh9HX14drr70WY2NjJfX4pbFz505ccMEFc98c37x5M7785S/P/X45jHEhd9xxBzzPw8033zxXWw7j/OM//mN4njfvZ9OmTXO/Xw5j/DEvvPACfud3fgfDw8OoVqt461vfikcffXTu9z/vZ9CSXYD+1//6X7j11ltx22234bvf/S4uvPBCXHnllTh69GjZXXvJzMzM4MILL8SOHTvo7z/xiU/g05/+ND772c/ikUceQb1ex5VXXmm60C5F9uzZg61bt+Lhhx/GV77yFfR6Pfzar/0aZmb+xXH7lltuwQMPPID77rsPe/bsweHDh3HNNdeU2OvFs27dOtxxxx3Yt28fHn30UVxxxRW4+uqr8cMf/hDA8hjjT/Kd73wHf/3Xf40LLrhgXn25jPMtb3kLjhw5MvfzzW9+c+53y2WMJ0+exOWXX44oivDlL38ZTzzxBP7rf/2vGBwcnGvzc38GFUuUd7zjHcXWrVvn/j/LsmLt2rXF9u3bS+zVmQNAcf/998/9f57nxerVq4tPfvKTc7Xx8fEiSZLif/7P/1lCD88MR48eLQAUe/bsKYri1JiiKCruu+++uTb/9E//VAAo9u7dW1Y3zwiDg4PFf/tv/23ZjXFqaqo455xziq985SvFL/3SLxUf+tCHiqJYPtfytttuKy688EL6u+UyxqIoij/8wz8s3vWud5m/L+MZtCTfAXW7Xezbtw9btmyZq/m+jy1btmDv3r0l9uyV48CBAxgdHZ035oGBAVx22WWv6jFPTEwAAIaGhgAA+/btQ6/XmzfOTZs2YcOGDa/acWZZhl27dmFmZgabN29edmPcunUrfv3Xf33eeIDldS2ffPJJrF27Fq9//etx3XXX4eDBgwCW1xj/4R/+AZdccgl+8zd/E6tWrcJFF12Ez3/+83O/L+MZtCQXoOPHjyPLMoyMjMyrj4yMYHR0tKRevbL8eFzLacx5nuPmm2/G5ZdfjvPPPx/AqXHGcYxmszmv7atxnI8//jj6+vqQJAk++MEP4v7778d55523rMa4a9cufPe738X27dud3y2XcV522WW455578OCDD2Lnzp04cOAAfvEXfxFTU1PLZowA8Mwzz2Dnzp0455xz8NBDD+GGG27A7//+7+MLX/gCgHKeQUsujkEsH7Zu3Yof/OAH8z5PX068+c1vxmOPPYaJiQn83d/9Ha6//nrs2bOn7G6dMQ4dOoQPfehD+MpXvoJKpVJ2d14xrrrqqrn/vuCCC3DZZZfh7LPPxhe/+EVUq9USe3ZmyfMcl1xyCT7+8Y8DAC666CL84Ac/wGc/+1lcf/31pfRpSb4DWrFiBYIgcJQmY2NjWL16dUm9emX58biWy5hvvPFG/OM//iO+9rWvzUtEXL16NbrdLsbHx+e1fzWOM45jvPGNb8TFF1+M7du348ILL8Rf/MVfLJsx7tu3D0ePHsXb3/52hGGIMAyxZ88efPrTn0YYhhgZGVkW41xIs9nEm970Jjz11FPL5loCwJo1a3DeeefNq5177rlzHzeW8QxakgtQHMe4+OKLsXv37rlanufYvXs3Nm/eXGLPXjk2btyI1atXzxvz5OQkHnnkkVfVmIuiwI033oj7778fX/3qV7Fx48Z5v7/44osRRdG8ce7fvx8HDx58VY2Tkec5Op3Oshnju9/9bjz++ON47LHH5n4uueQSXHfddXP/vRzGuZDp6Wk8/fTTWLNmzbK5lgBw+eWXO1+J+NGPfoSzzz4bQEnPoFdE2nAG2LVrV5EkSXHPPfcUTzzxRPGBD3ygaDabxejoaNlde8lMTU0V3/ve94rvfe97BYDiz//8z4vvfe97xXPPPVcURVHccccdRbPZLP7+7/+++P73v19cffXVxcaNG4tWq1Vyz0+fG264oRgYGCi+/vWvF0eOHJn7mZ2dnWvzwQ9+sNiwYUPx1a9+tXj00UeLzZs3F5s3by6x14vnIx/5SLFnz57iwIEDxfe///3iIx/5SOF5XvF//s//KYpieYyR8ZMquKJYHuP88Ic/XHz9618vDhw4UHzrW98qtmzZUqxYsaI4evRoURTLY4xFURTf/va3izAMiz/7sz8rnnzyyeJv//Zvi1qtVvyP//E/5tr8vJ9BS3YBKoqi+Mu//Mtiw4YNRRzHxTve8Y7i4YcfLrtLL4uvfe1rBQDn5/rrry+K4pQM8qMf/WgxMjJSJElSvPvd7y72799fbqcXCRsfgOLuu++ea9NqtYr/+B//YzE4OFjUarXi3/ybf1McOXKkvE6/BP7Df/gPxdlnn13EcVysXLmyePe73z23+BTF8hgjY+ECtBzG+b73va9Ys2ZNEcdxcdZZZxXve9/7iqeeemru98thjD/mgQceKM4///wiSZJi06ZNxec+97l5v/95P4OUBySEEKIUluQekBBCiOWPFiAhhBCloAVICCFEKWgBEkIIUQpagIQQQpSCFiAhhBCloAVICCFEKWgBEkIIUQpagIQQQpSCFiAhhBCloAVICCFEKfz/IDYCE5sn/zEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture\n",
    "index = 2\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print(train_set_x_orig[index].shape) #(64, 64, 3),一张图片对于的三维矩阵\n",
    "print (\"y = \" + str(train_set_y[:, index]) + \", it's a '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many software bugs in deep learning come from having matrix/vector dimensions that don't fit. If you can keep your matrix/vector dimensions straight you will go a long way toward eliminating many bugs. \n",
    "\n",
    "<a name='ex-1'></a>\n",
    "### Exercise 1\n",
    "Find the values for:\n",
    "    - m_train (number of training examples)\n",
    "    - m_test (number of test examples)\n",
    "    - num_px (= height = width of a training image)\n",
    "Remember that `train_set_x_orig` is a numpy-array of shape (m_train, num_px, num_px, 3). For instance, you can access `m_train` by writing `train_set_x_orig.shape[0]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "921fe679a632ec7ec9963069fa405725",
     "grade": false,
     "grade_id": "cell-c4e7e9c1f174eb83",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training examples: m_train = 209\n",
      "Number of testing examples: m_test = [[[158 104  83]\n",
      "  [161 106  85]\n",
      "  [162 107  84]\n",
      "  ...\n",
      "  [170 120 100]\n",
      "  [167 121 103]\n",
      "  [172 127 109]]\n",
      "\n",
      " [[158 103  82]\n",
      "  [160 104  82]\n",
      "  [162 105  83]\n",
      "  ...\n",
      "  [169 118  99]\n",
      "  [164 117  98]\n",
      "  [168 121 104]]\n",
      "\n",
      " [[158 104  82]\n",
      "  [161 105  82]\n",
      "  [162 105  83]\n",
      "  ...\n",
      "  [173 123 102]\n",
      "  [169 122 104]\n",
      "  [168 122 104]]\n",
      "\n",
      " ...\n",
      "\n",
      " [[102  68  52]\n",
      "  [ 44  31  23]\n",
      "  [ 28  23  20]\n",
      "  ...\n",
      "  [163 118 102]\n",
      "  [163 120 103]\n",
      "  [166 121 105]]\n",
      "\n",
      " [[ 99  67  51]\n",
      "  [ 38  28  22]\n",
      "  [ 30  26  23]\n",
      "  ...\n",
      "  [161 117 100]\n",
      "  [164 121 104]\n",
      "  [168 123 106]]\n",
      "\n",
      " [[127  95  72]\n",
      "  [ 39  29  22]\n",
      "  [ 30  25  22]\n",
      "  ...\n",
      "  [165 122 105]\n",
      "  [169 126 109]\n",
      "  [173 128 110]]]\n",
      "Height/Width of each image: num_px = 64\n",
      "Each image is of size: (64, 64, 3)\n",
      "train_set_x shape: (209, 64, 64, 3)\n",
      "train_set_y shape: (1, 209)\n",
      "test_set_x shape: (50, 64, 64, 3)\n",
      "test_set_y shape: (1, 50)\n"
     ]
    }
   ],
   "source": [
    "#(≈ 3 lines of code)\n",
    "# m_train = \n",
    "# m_test = \n",
    "# num_px = \n",
    "# YOUR CODE STARTS HERE\n",
    "m_train = train_set_x_orig.shape[0] #训练集中有多少张照片\n",
    "m_test = test_set_x_orig[0]#第一张照片对于的三维矩阵\n",
    "num_px = train_set_x_orig.shape[1]\n",
    "# YOUR CODE ENDS HERE\n",
    "\n",
    "print (\"Number of training examples: m_train = \" + str(m_train))\n",
    "print (\"Number of testing examples: m_test = \" + str(m_test))\n",
    "print (\"Height/Width of each image: num_px = \" + str(num_px))\n",
    "print (\"Each image is of size: (\" + str(num_px) + \", \" + str(num_px) + \", 3)\")\n",
    "print (\"train_set_x shape: \" + str(train_set_x_orig.shape))\n",
    "print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "print (\"test_set_x shape: \" + str(test_set_x_orig.shape))\n",
    "print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output for m_train, m_test and num_px**: \n",
    "<table style=\"width:15%\">\n",
    "  <tr>\n",
    "    <td> m_train </td>\n",
    "    <td> 209 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>m_test</td>\n",
    "    <td> 50 </td> \n",
    "  </tr>\n",
    "  \n",
    "  <tr>\n",
    "    <td>num_px</td>\n",
    "    <td> 64 </td> \n",
    "  </tr>\n",
    "  \n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience, you should now reshape images of shape (num_px, num_px, 3) in a numpy-array of shape (num_px $*$ num_px $*$ 3, 1). After this, our training (and test) dataset is a numpy-array where each column represents a flattened image. There should be m_train (respectively m_test) columns.\n",
    "\n",
    "<a name='ex-2'></a>\n",
    "### Exercise 2\n",
    "Reshape the training and test data sets so that images of size (num_px, num_px, 3) are flattened into single vectors of shape (num\\_px $*$ num\\_px $*$ 3, 1).\n",
    "\n",
    "A trick when you want to flatten a matrix X of shape (a,b,c,d) to a matrix X_flatten of shape (b$*$c$*$d, a) is to use: \n",
    "```python\n",
    "X_flatten = X.reshape(X.shape[0], -1).T      # X.T is the transpose of X\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5a2aa62bdd8c01450111b758ef159aec",
     "grade": false,
     "grade_id": "cell-0f43921062c34e50",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# Reshape the training and test examples\n",
    "#(≈ 2 lines of code)\n",
    "# train_set_x_flatten = ...\n",
    "# test_set_x_flatten = ...\n",
    "# YOUR CODE STARTS HERE\n",
    "train_set_x_flatten=train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "test_set_x_flatten=test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T\n",
    "# YOUR CODE ENDS HERE\n",
    "\n",
    "# Check that the first 10 pixels of the second image are in the correct place\n",
    "# assert np.alltrue(train_set_x_flatten[0:10, 1] == [196, 192, 190, 193, 186, 182, 188, 179, 174, 213]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
    "# assert np.alltrue(test_set_x_flatten[0:10, 1] == [115, 110, 111, 137, 129, 129, 155, 146, 145, 159]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
    "assert np.all(train_set_x_flatten[0:10, 1] == [196, 192, 190, 193, 186, 182, 188, 179, 174, 213]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
    "assert np.all(test_set_x_flatten[0:10, 1] == [115, 110, 111, 137, 129, 129, 155, 146, 145, 159]), \"Wrong solution. Use (X.shape[0], -1).T.\"\n",
    "\n",
    "# print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
    "# print (\"train_set_y shape: \" + str(train_set_y.shape))\n",
    "# print (\"test_set_x_flatten shape: \" + str(test_set_x_flatten.shape))\n",
    "# print (\"test_set_y shape: \" + str(test_set_y.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected Output**: \n",
    "\n",
    "<table style=\"width:35%\">\n",
    "  <tr>\n",
    "    <td>train_set_x_flatten shape</td>\n",
    "    <td> (12288, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>train_set_y shape</td>\n",
    "    <td>(1, 209)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>test_set_x_flatten shape</td>\n",
    "    <td>(12288, 50)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>test_set_y shape</td>\n",
    "    <td>(1, 50)</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To represent color images, the red, green and blue channels (RGB) must be specified for each pixel, and so the pixel value is actually a vector of three numbers ranging from 0 to 255.\n",
    "\n",
    "One common preprocessing step in machine learning is to center and standardize your dataset, meaning that you substract the mean of the whole numpy array from each example, and then divide each example by the standard deviation of the whole numpy array. But for picture datasets, it is simpler and more convenient and works almost as well to just divide every row of the dataset by 255 (the maximum value of a pixel channel).\n",
    "\n",
    "<!-- During the training of your model, you're going to multiply weights and add biases to some initial inputs in order to observe neuron activations. Then you backpropogate with the gradients to train the model. But, it is extremely important for each feature to have a similar range such that our gradients don't explode. You will see that more in detail later in the lectures. !--> \n",
    "\n",
    "Let's standardize our dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x = train_set_x_flatten / 255.\n",
    "test_set_x = test_set_x_flatten / 255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "    \n",
    "    \n",
    "**What you need to remember:**\n",
    "\n",
    "Common steps for pre-processing a new dataset are:\n",
    "- Figure out the dimensions and shapes of the problem (m_train, m_test, num_px, ...)\n",
    "- Reshape the datasets such that each example is now a vector of size (num_px \\* num_px \\* 3, 1)\n",
    "- \"Standardize\" the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "<a name='3'></a>\n",
    "## 3 - General Architecture of the learning algorithm ##\n",
    "\n",
    "It's time to design a simple algorithm to distinguish cat images from non-cat images.\n",
    "\n",
    "You will build a Logistic Regression, using a Neural Network mindset. The following Figure explains why **Logistic Regression is actually a very simple Neural Network!**\n",
    "\n",
    "<img src=\"images/LogReg_kiank.png\" style=\"width:650px;height:400px;\">\n",
    "\n",
    "**Mathematical expression of the algorithm**:\n",
    "\n",
    "For one example $x^{(i)}$:\n",
    "$$z^{(i)} = w^T x^{(i)} + b \\tag{1}$$\n",
    "$$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})\\tag{2}$$ \n",
    "$$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})\\tag{3}$$\n",
    "\n",
    "The cost is then computed by summing over all training examples:\n",
    "$$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})\\tag{6}$$\n",
    "\n",
    "**Key steps**:\n",
    "In this exercise, you will carry out the following steps: \n",
    "    - Initialize the parameters of the model\n",
    "    - Learn the parameters for the model by minimizing the cost  \n",
    "    - Use the learned parameters to make predictions (on the test set)\n",
    "    - Analyse the results and conclude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4'></a>\n",
    "## 4 - Building the parts of our algorithm ## \n",
    "\n",
    "The main steps for building a Neural Network are:\n",
    "1. Define the model structure (such as number of input features) \n",
    "2. Initialize the model's parameters\n",
    "3. Loop:\n",
    "    - Calculate current loss (forward propagation)\n",
    "    - Calculate current gradient (backward propagation)\n",
    "    - Update parameters (gradient descent)\n",
    "\n",
    "You often build 1-3 separately and integrate them into one function we call `model()`.\n",
    "\n",
    "<a name='4-1'></a>\n",
    "### 4.1 - Helper functions\n",
    "\n",
    "<a name='ex-3'></a>\n",
    "### Exercise 3 - sigmoid\n",
    "Using your code from \"Python Basics\", implement `sigmoid()`. As you've seen in the figure above, you need to compute $sigmoid(z) = \\frac{1}{1 + e^{-z}}$ for $z = w^T x + b$ to make predictions. Use np.exp()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "239ab1cf1028b721fd14f31b8103c40d",
     "grade": false,
     "grade_id": "cell-520521c430352f3b",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: sigmoid\n",
    "\n",
    "def sigmoid(z):\n",
    "    \"\"\"\n",
    "    Compute the sigmoid of z\n",
    "\n",
    "    Arguments:\n",
    "    z -- A scalar or numpy array of any size.\n",
    "\n",
    "    Return:\n",
    "    s -- sigmoid(z)\n",
    "    \"\"\"\n",
    "\n",
    "    #(≈ 1 line of code)\n",
    "    # s = ...\n",
    "    # YOUR CODE STARTS HERE\n",
    "    s=1/(1+np.exp(-z))\n",
    "    \n",
    "    # YOUR CODE ENDS HERE\n",
    "    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "0483e6820669111a9c5914d8b24bc315",
     "grade": true,
     "grade_id": "cell-30ea3151cab9c491",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid([0, 2]) = [0.5        0.88079708]\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))\n",
    "\n",
    "sigmoid_test(sigmoid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.62245933 0.5        0.88079708]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([0.5, 0, 2.0])\n",
    "output = sigmoid(x)\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-2'></a>\n",
    "### 4.2 - Initializing parameters\n",
    "\n",
    "<a name='ex-4'></a>\n",
    "### Exercise 4 - initialize_with_zeros\n",
    "Implement parameter initialization in the cell below. You have to initialize w as a vector of zeros. If you don't know what numpy function to use, look up np.zeros() in the Numpy library's documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "c4a37e375a85ddab7274a33abf46bb7c",
     "grade": false,
     "grade_id": "cell-befa9335e479864e",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: initialize_with_zeros\n",
    "\n",
    "def initialize_with_zeros(dim):\n",
    "    \"\"\"\n",
    "    This function creates a vector of zeros of shape (dim, 1) for w and initializes b to 0.\n",
    "    \n",
    "    Argument:\n",
    "    dim -- size of the w vector we want (or number of parameters in this case)\n",
    "    \n",
    "    Returns:\n",
    "    w -- initialized vector of shape (dim, 1)\n",
    "    b -- initialized scalar (corresponds to the bias) of type float\n",
    "    \"\"\"\n",
    "    \n",
    "    # (≈ 2 lines of code)\n",
    "    # w = ...\n",
    "    # b = ...\n",
    "    # YOUR CODE STARTS HERE\n",
    "    w=np.zeros((dim,1))\n",
    "    b=0.0\n",
    "    \n",
    "    # YOUR CODE ENDS HERE\n",
    "\n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "a1f856df8b35b664982b6e4ca82681cf",
     "grade": true,
     "grade_id": "cell-a3b6699f145f3a3f",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.]\n",
      " [0.]]\n",
      "b = 0.0\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "dim = 2\n",
    "w, b = initialize_with_zeros(dim)\n",
    "\n",
    "assert type(b) == float\n",
    "print (\"w = \" + str(w))\n",
    "print (\"b = \" + str(b))\n",
    "\n",
    "initialize_with_zeros_test(initialize_with_zeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-3'></a>\n",
    "### 4.3 - Forward and Backward propagation\n",
    "\n",
    "Now that your parameters are initialized, you can do the \"forward\" and \"backward\" propagation steps for learning the parameters.\n",
    "\n",
    "<a name='ex-5'></a>\n",
    "### Exercise 5 - propagate\n",
    "Implement a function `propagate()` that computes the cost function and its gradient.\n",
    "\n",
    "**Hints**:\n",
    "\n",
    "Forward Propagation:\n",
    "- You get X\n",
    "- You compute $A = \\sigma(w^T X + b) = (a^{(1)}, a^{(2)}, ..., a^{(m-1)}, a^{(m)})$\n",
    "- You calculate the cost function: $J = -\\frac{1}{m}\\sum_{i=1}^{m}(y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)}))$\n",
    "\n",
    "Here are the two formulas you will be using: \n",
    "\n",
    "$$ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T\\tag{7}$$\n",
    "$$ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})\\tag{8}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "8c7fa5fd813679d86ba0032de1f813eb",
     "grade": false,
     "grade_id": "cell-11af17e28077b3d3",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: propagate\n",
    "\n",
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    Implement the cost function and its gradient for the propagation explained above\n",
    "\n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat) of size (1, number of examples)\n",
    "\n",
    "    Return:\n",
    "    cost -- negative log-likelihood cost for logistic regression\n",
    "    dw -- gradient of the loss with respect to w, thus same shape as w\n",
    "    db -- gradient of the loss with respect to b, thus same shape as b\n",
    "    \n",
    "    Tips:\n",
    "    - Write your code step by step for the propagation. np.log(), np.dot()\n",
    "    \"\"\"\n",
    "    \n",
    "    m = X.shape[1] #样本数量\n",
    "    \n",
    "    # FORWARD PROPAGATION (FROM X TO COST)\n",
    "    #(≈ 2 lines of code)\n",
    "    # compute activation\n",
    "    # A = ...\n",
    "    # compute cost using np.dot. Don't use loops for the sum.\n",
    "    # cost = ...                                \n",
    "    # YOUR CODE STARTS HERE\n",
    "    A=sigmoid(np.dot(w.T,X)+b) # A (1,number of examples)\n",
    "    cost=-( np.dot(Y,np.log(A.T)) + np.dot((1-Y),np.log((1-A).T)) )/m # 常数\n",
    "    # YOUR CODE ENDS HERE\n",
    "\n",
    "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
    "    #(≈ 2 lines of code)\n",
    "    # dw = ...\n",
    "    # db = ...\n",
    "    # YOUR CODE STARTS HERE\n",
    "    dw=(np.dot(X,(A-Y).T))/m\n",
    "    db=np.sum(A-Y)/m\n",
    "    # YOUR CODE ENDS HERE\n",
    "    cost = np.squeeze(np.array(cost))\n",
    "\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "48874865ce7cec6f03c3fae76f8bbfbe",
     "grade": true,
     "grade_id": "cell-d1594d75b61dd554",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[0.99845601]\n",
      " [2.39507239]]\n",
      "db = 0.001455578136784208\n",
      "cost = 5.801545319394553\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "w =  np.array([[1.], [2.]])\n",
    "b = 2.\n",
    "X =np.array([[1., 2., -1.], [3., 4., -3.2]])\n",
    "Y = np.array([[1, 0, 1]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "\n",
    "assert type(grads[\"dw\"]) == np.ndarray\n",
    "assert grads[\"dw\"].shape == (2, 1)\n",
    "assert type(grads[\"db\"]) == np.float64\n",
    "\n",
    "\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))\n",
    "\n",
    "propagate_test(propagate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Expected output**\n",
    "\n",
    "```\n",
    "dw = [[0.99845601]\n",
    " [2.39507239]]\n",
    "db = 0.001455578136784208\n",
    "cost = 5.801545319394553\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='4-4'></a>\n",
    "### 4.4 - Optimization\n",
    "- You have initialized your parameters.\n",
    "- You are also able to compute a cost function and its gradient.\n",
    "- Now, you want to update the parameters using gradient descent.\n",
    "\n",
    "<a name='ex-6'></a>\n",
    "### Exercise 6 - optimize\n",
    "Write down the optimization function. The goal is to learn $w$ and $b$ by minimizing the cost function $J$. For a parameter $\\theta$, the update rule is $ \\theta = \\theta - \\alpha \\text{ } d\\theta$, where $\\alpha$ is the learning rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "49d9b4c1a780bf141c8eb48e06cbb494",
     "grade": false,
     "grade_id": "cell-616d6883e807448d",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: optimize\n",
    "\n",
    "def optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False):\n",
    "    \"\"\"\n",
    "    This function optimizes w and b by running a gradient descent algorithm\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of shape (num_px * num_px * 3, number of examples)\n",
    "    Y -- true \"label\" vector (containing 0 if non-cat, 1 if cat), of shape (1, number of examples)\n",
    "    num_iterations -- number of iterations of the optimization loop\n",
    "    learning_rate -- learning rate of the gradient descent update rule\n",
    "    print_cost -- True to print the loss every 100 steps\n",
    "    \n",
    "    Returns:\n",
    "    params -- dictionary containing the weights w and bias b\n",
    "    grads -- dictionary containing the gradients of the weights and bias with respect to the cost function\n",
    "    costs -- list of all the costs computed during the optimization, this will be used to plot the learning curve.\n",
    "    \n",
    "    Tips:\n",
    "    You basically need to write down two steps and iterate through them:\n",
    "        1) Calculate the cost and the gradient for the current parameters. Use propagate().\n",
    "        2) Update the parameters using gradient descent rule for w and b.\n",
    "    \"\"\"\n",
    "    \n",
    "    w = copy.deepcopy(w)\n",
    "    b = copy.deepcopy(b)\n",
    "    \n",
    "    costs = []\n",
    "    \n",
    "    for i in range(num_iterations):\n",
    "        # (≈ 1 lines of code)\n",
    "        # Cost and gradient calculation \n",
    "        # grads, cost = ...\n",
    "        # YOUR CODE STARTS HERE\n",
    "        grads, cost=propagate(w, b, X, Y)\n",
    "        \n",
    "        # YOUR CODE ENDS HERE\n",
    "        \n",
    "        # Retrieve derivatives from grads\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        \n",
    "        # update rule (≈ 2 lines of code)\n",
    "        # w = ...\n",
    "        # b = ...\n",
    "        # YOUR CODE STARTS HERE\n",
    "        w=w-learning_rate*dw\n",
    "        b=b-learning_rate*db\n",
    "        \n",
    "        # YOUR CODE ENDS HERE\n",
    "        \n",
    "        # Record the costs\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        \n",
    "            # Print the cost every 100 training iterations\n",
    "            if print_cost:\n",
    "                print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    \n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "b65a5c90f86a990614156e41f64b4678",
     "grade": true,
     "grade_id": "cell-8e3d43fbb82a8901",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.19033591]\n",
      " [0.12259159]]\n",
      "b = 1.9253598300845747\n",
      "dw = [[0.67752042]\n",
      " [1.41625495]]\n",
      "db = 0.21919450454067657\n",
      "Costs = [array(5.80154532)]\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False)\n",
    "\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print(\"Costs = \" + str(costs))\n",
    "\n",
    "optimize_test(optimize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='ex-7'></a>\n",
    "### Exercise 7 - predict\n",
    "The previous function will output the learned w and b. We are able to use w and b to predict the labels for a dataset X. Implement the `predict()` function. There are two steps to computing predictions:\n",
    "\n",
    "1. Calculate $\\hat{Y} = A = \\sigma(w^T X + b)$\n",
    "\n",
    "2. Convert the entries of a into 0 (if activation <= 0.5) or 1 (if activation > 0.5), stores the predictions in a vector `Y_prediction`. If you wish, you can use an `if`/`else` statement in a `for` loop (though there is also a way to vectorize this). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e56419b97ebf382a8f93ac2873988887",
     "grade": false,
     "grade_id": "cell-d6f924f49c51dc2f",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: predict\n",
    "\n",
    "def predict(w, b, X):\n",
    "    '''\n",
    "    Predict whether the label is 0 or 1 using learned logistic regression parameters (w, b)\n",
    "    \n",
    "    Arguments:\n",
    "    w -- weights, a numpy array of size (num_px * num_px * 3, 1)\n",
    "    b -- bias, a scalar\n",
    "    X -- data of size (num_px * num_px * 3, number of examples)\n",
    "    \n",
    "    Returns:\n",
    "    Y_prediction -- a numpy array (vector) containing all predictions (0/1) for the examples in X\n",
    "    '''\n",
    "    \n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1, m))\n",
    "    w = w.reshape(X.shape[0], 1)\n",
    "    \n",
    "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
    "    #(≈ 1 line of code)\n",
    "    # A = ...\n",
    "    # YOUR CODE STARTS HERE\n",
    "    A=sigmoid(np.dot(w.T,X)+b)\n",
    "    assert(A.shape==(1,X.shape[1]))\n",
    "    # YOUR CODE ENDS HERE\n",
    "    \n",
    "    for i in range(A.shape[1]):\n",
    "        \n",
    "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
    "        #(≈ 4 lines of code)\n",
    "        # if A[0, i] > ____ :\n",
    "        #     Y_prediction[0,i] = \n",
    "        # else:\n",
    "        #     Y_prediction[0,i] = \n",
    "        # YOUR CODE STARTS HERE\n",
    "        if A[0, i] > 0.5 :\n",
    "            Y_prediction[0,i] =1 \n",
    "        else:\n",
    "            Y_prediction[0,i] = 0\n",
    "        \n",
    "        # YOUR CODE ENDS HERE\n",
    "    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "e3ea12608f15798d542a07c1bc9f561b",
     "grade": true,
     "grade_id": "cell-90b1fb967269548c",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[1. 1. 0.]]\n",
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "w = np.array([[0.1124579], [0.23106775]])\n",
    "b = -0.3\n",
    "X = np.array([[1., -1.1, -3.2],[1.2, 2., 0.1]])\n",
    "print (\"predictions = \" + str(predict(w, b, X)))\n",
    "\n",
    "predict_test(predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "    \n",
    "**What to remember:**\n",
    "    \n",
    "You've implemented several functions that:\n",
    "- Initialize (w,b)\n",
    "- Optimize the loss iteratively to learn parameters (w,b):\n",
    "    - Computing the cost and its gradient \n",
    "    - Updating the parameters using gradient descent\n",
    "- Use the learned (w,b) to predict the labels for a given set of examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='5'></a>\n",
    "## 5 - Merge all functions into a model ##\n",
    "\n",
    "You will now see how the overall model is structured by putting together all the building blocks (functions implemented in the previous parts) together, in the right order.\n",
    "\n",
    "<a name='ex-8'></a>\n",
    "### Exercise 8 - model\n",
    "Implement the model function. Use the following notation:\n",
    "    - Y_prediction_test for your predictions on the test set\n",
    "    - Y_prediction_train for your predictions on the train set\n",
    "    - parameters, grads, costs for the outputs of optimize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "5b84120627479b28a106a86b61efd80e",
     "grade": false,
     "grade_id": "cell-6dcba5967c4cbf8c",
     "locked": false,
     "schema_version": 3,
     "solution": true,
     "task": false
    }
   },
   "outputs": [],
   "source": [
    "# GRADED FUNCTION: model\n",
    "\n",
    "def model(X_train, Y_train, X_test, Y_test, num_iterations=2000, learning_rate=0.5, print_cost=False):\n",
    "    \"\"\"\n",
    "    Builds the logistic regression model by calling the function you've implemented previously\n",
    "    \n",
    "    Arguments:\n",
    "    X_train -- training set represented by a numpy array of shape (num_px * num_px * 3, m_train)\n",
    "    Y_train -- training labels represented by a numpy array (vector) of shape (1, m_train)\n",
    "    X_test -- test set represented by a numpy array of shape (num_px * num_px * 3, m_test)\n",
    "    Y_test -- test labels represented by a numpy array (vector) of shape (1, m_test)\n",
    "    num_iterations -- hyperparameter representing the number of iterations to optimize the parameters\n",
    "    learning_rate -- hyperparameter representing the learning rate used in the update rule of optimize()\n",
    "    print_cost -- Set to True to print the cost every 100 iterations\n",
    "    \n",
    "    Returns:\n",
    "    d -- dictionary containing information about the model.\n",
    "    \"\"\"\n",
    "    # (≈ 1 line of code)   \n",
    "    # initialize parameters with zeros \n",
    "    # w, b = ...\n",
    "    \n",
    "    #(≈ 1 line of code)\n",
    "    # Gradient descent \n",
    "    # parameters, grads, costs = ...\n",
    "    \n",
    "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
    "    # w = ...\n",
    "    # b = ...\n",
    "    \n",
    "    # Predict test/train set examples (≈ 2 lines of code)\n",
    "    # Y_prediction_test = ...\n",
    "    # Y_prediction_train = ...\n",
    "    \n",
    "    # YOUR CODE STARTS HERE\n",
    "    w,b=initialize_with_zeros(X_train.shape[0])\n",
    "    parameters, grads, costs=optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
    "    w=parameters[\"w\"]\n",
    "    b=parameters[\"b\"]\n",
    "    Y_prediction_test=predict(w, b, X_test)\n",
    "    Y_prediction_train=predict(w, b, X_train)\n",
    "    # YOUR CODE ENDS HERE\n",
    "\n",
    "    # Print train/test Errors\n",
    "    if print_cost:\n",
    "        print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "        print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n",
    "\n",
    "    \n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": Y_prediction_test, \n",
    "         \"Y_prediction_train\" : Y_prediction_train, \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations}\n",
    "    \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "cell_type": "code",
     "checksum": "ef861169461a4c80af845379770efe90",
     "grade": true,
     "grade_id": "cell-4170e070f3cde17e",
     "locked": true,
     "points": 10,
     "schema_version": 3,
     "solution": false,
     "task": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[92mAll tests passed!\n"
     ]
    }
   ],
   "source": [
    "model_test(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you pass all the tests, run the following cell to train your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "train accuracy: 99.04306220095694 %\n",
      "test accuracy: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "logistic_regression_model = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=2000, learning_rate=0.005, print_cost=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Comment**: Training accuracy is close to 100%. This is a good sanity check: your model is working and has high enough capacity to fit the training data. Test accuracy is 70%. It is actually not bad for this simple model, given the small dataset we used and that logistic regression is a linear classifier. But no worries, you'll build an even better classifier next week!\n",
    "\n",
    "Also, you see that the model is clearly overfitting the training data. Later in this specialization you will learn how to reduce overfitting, for example by using regularization. Using the code below (and changing the `index` variable) you can look at predictions on pictures of the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 1, you predicted that it is a \"cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example of a picture that was wrongly classified.\n",
    "index = 1\n",
    "plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[int(logistic_regression_model['Y_prediction_test'][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's also plot the cost function and the gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot learning curve (with costs)\n",
    "costs = np.squeeze(logistic_regression_model['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(logistic_regression_model[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interpretation**:\n",
    "You can see the cost decreasing. It shows that the parameters are being learned. However, you see that you could train the model even more on the training set. Try to increase the number of iterations in the cell above and rerun the cells. You might see that the training set accuracy goes up, but the test set accuracy goes down. This is called overfitting. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='6'></a>\n",
    "## 6 - Further analysis (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on building your first image classification model. Let's analyze it further, and examine possible choices for the learning rate $\\alpha$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Choice of learning rate ####\n",
    "\n",
    "**Reminder**:\n",
    "In order for Gradient Descent to work you must choose the learning rate wisely. The learning rate $\\alpha$  determines how rapidly we update the parameters. If the learning rate is too large we may \"overshoot\" the optimal value. Similarly, if it is too small we will need too many iterations to converge to the best values. That's why it is crucial to use a well-tuned learning rate.\n",
    "\n",
    "Let's compare the learning curve of our model with several choices of learning rates. Run the cell below. This should take about 1 minute. Feel free also to try different values than the three we have initialized the `learning_rates` variable to contain, and see what happens. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "\n",
    "for lr in learning_rates:\n",
    "    print (\"Training a model with learning rate: \" + str(lr))\n",
    "    models[str(lr)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=1500, learning_rate=lr, print_cost=False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for lr in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(lr)][\"costs\"]), label=str(models[str(lr)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (hundreds)')\n",
    "\n",
    "legend = plt.legend(loc='upper center', shadow=True)\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Interpretation**: \n",
    "- Different learning rates give different costs and thus different predictions results.\n",
    "- If the learning rate is too large (0.01), the cost may oscillate up and down. It may even diverge (though in this example, using 0.01 still eventually ends up at a good value for the cost). \n",
    "- A lower cost doesn't mean a better model. You have to check if there is possibly overfitting. It happens when the training accuracy is a lot higher than the test accuracy.\n",
    "- In deep learning, we usually recommend that you: \n",
    "    - Choose the learning rate that better minimizes the cost function.\n",
    "    - If your model overfits, use other techniques to reduce overfitting. (We'll talk about this in later videos.) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='7'></a>\n",
    "## 7 - Test with your own image (optional/ungraded exercise) ##\n",
    "\n",
    "Congratulations on finishing this assignment. You can use your own image and see the output of your model. To do that:\n",
    "    1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n",
    "    2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n",
    "    3. Change your image's name in the following code\n",
    "    4. Run the code and check if the algorithm is right (1 = cat, 0 = non-cat)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0.0, your algorithm predicts a \"non-cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# change this to the name of your image file\n",
    "my_image = \"f1.jpg\"   \n",
    "\n",
    "# We preprocess the image to fit your algorithm.\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(Image.open(fname).resize((num_px, num_px)))\n",
    "plt.imshow(image)\n",
    "image = image / 255.\n",
    "image = image.reshape((1, num_px * num_px * 3)).T\n",
    "my_predicted_image = predict(logistic_regression_model[\"w\"], logistic_regression_model[\"b\"], image)\n",
    "\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \", your algorithm predicts a \\\"\" + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color='blue'>\n",
    "    \n",
    "**What to remember from this assignment:**\n",
    "1. Preprocessing the dataset is important.\n",
    "2. You implemented each function separately: initialize(), propagate(), optimize(). Then you built a model().\n",
    "3. Tuning the learning rate (which is an example of a \"hyperparameter\") can make a big difference to the algorithm. You will see more examples of this later in this course!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, if you'd like, we invite you to try different things on this Notebook. Make sure you submit before trying anything. Once you submit, things you can play with include:\n",
    "    - Play with the learning rate and the number of iterations\n",
    "    - Try different initialization methods and compare the results\n",
    "    - Test other preprocessings (center the data, or divide each row by its standard deviation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bibliography:\n",
    "- http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/\n",
    "- https://stats.stackexchange.com/questions/211436/why-do-we-normalize-images-by-subtracting-the-datasets-image-mean-and-not-the-c"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
